|
| DiagnosticState & | current_diagnostic_state () |
| | Get the current diagnostic state.
|
| std::vector< Diagnosis > & | current_diagnoses () |
| | Get the current diagnoses.
|
| std::vector< Diagnosis > | diagnose (const DiagnosticsInterface &) |
| | A helper function to diagnose common setup errors.
|
| void | diagnose_and_throw (const DiagnosticsInterface &) |
| | A helper function to diagnose common setup errors and throw an exception if any errors are found.
|
| template<typename... Args> |
| void | diagnostic_assert (bool, Args &&...) |
| | Helper assertion function for diagnostics.
|
| template<typename... Args> |
| void | diagnostic_assert (bool assertion, Args &&... args) |
| std::ostream & | operator<< (std::ostream &, const EnumSelection &) |
| std::stringstream & | operator>> (std::stringstream &, EnumSelection &) |
| std::map< std::string, std::map< std::string, unsigned long > > & | timed_sections () |
| std::ostream & | operator<< (std::ostream &os, const InputFile &p) |
| std::ostream & | operator<< (std::ostream &os, const LabeledAxis &axis) |
| bool | operator== (const LabeledAxis &a, const LabeledAxis &b) |
| bool | operator!= (const LabeledAxis &a, const LabeledAxis &b) |
| std::vector< std::string > | reserved_subaxis_names () |
| bool | operator== (const LabeledAxisAccessor &a, const LabeledAxisAccessor &b) |
| | Compare for equality between two LabeledAxisAccessor.
|
| bool | operator!= (const LabeledAxisAccessor &a, const LabeledAxisAccessor &b) |
| | Compare for equality between two LabeledAxisAccessor.
|
| bool | operator< (const LabeledAxisAccessor &a, const LabeledAxisAccessor &b) |
| | The (strict) smaller than operator is created so as to use LabeledAxisAccessor in sorted data structures.
|
| std::ostream & | operator<< (std::ostream &os, const LabeledAxisAccessor &accessor) |
| | Serialize the accessor into a string. The format is simply the concatenation of all the item names delimited by "/".
|
| std::ostream & | operator<< (std::ostream &, const MultiEnumSelection &) |
| std::stringstream & | operator>> (std::stringstream &, MultiEnumSelection &) |
| std::ostream & | operator<< (std::ostream &, const OptionBase &) |
| bool | options_compatible (const OptionSet &opts, const OptionSet &additional_opts) |
| std::ostream & | operator<< (std::ostream &os, const OptionSet &p) |
| template<typename T> |
| std::stringstream & | operator>> (std::stringstream &ss, TensorName< T > &t) |
| | Stream into a TensorName (used by Parsers to extract input options).
|
| template<typename T> |
| std::ostream & | operator<< (std::ostream &os, const TensorName< T > &t) |
| | Stream out a TensorName (used for printing OptionSet).
|
| std::unordered_map< std::string, std::unique_ptr< TraceWriter > > & | event_trace_writers () |
| | All trace writers.
|
| DerivMap | derivmap_cat_reduce (std::vector< DerivMap > &&results, Size dynamic_dim) |
| | Concatenate the tensors in the DerivMap along the batch dimension.
|
| DerivMap | derivmap_move_device (DerivMap &&x, Device device) |
| | Move all tensors in a DerivMap to a device.
|
| DerivMap | derivmap_no_operation (DerivMap &&x) |
| | No operation.
|
| ValueMap | valuemap_cat_reduce (const std::vector< ValueMap > &results, Size dynamic_dim) |
| | Concatenate the tensors in the ValueMap along the batch dimension.
|
| ValueMap | valuemap_move_device (ValueMap &&x, Device device) |
| | Move all tensors in a ValueMap to a device.
|
| ValueMap | valuemap_no_operation (ValueMap &&x) |
| | No operation.
|
| Tensor | pop_intrsc_intmd_dim (const Tensor &t, Size dim) |
| | Move the trailing dim intermediate dimensions to the base.
|
| Tensor | push_intrsc_intmd_dim (const Tensor &t, Size dim) |
| | Move the leading dim base dimensions to intermediate dimensions.
|
| Tensor | pop_intrsc_intmd_dim (const Derivative< 1 > &deriv) |
| template<std::size_t N> |
| Tensor | pop_intrsc_intmd_dim (const Tensor &from, const std::array< std::size_t, N > &intrsc_intmd_dims, const std::array< TensorShape, N > &base_shapes, const std::string &debug_name="<anonymous>") |
| template<std::size_t N> |
| Tensor | push_intrsc_intmd_dim (const Tensor &from, const std::array< std::size_t, N > &intrsc_intmd_dims, const std::array< TensorShape, N > &base_shapes, const std::string &debug_name="<anonymous>") |
| template<std::size_t N> |
| Tensor | from_assembly (const Tensor &from, const std::array< TensorShape, N > &intmd_shapes, const std::array< TensorShape, N > &base_shapes) |
| template<std::size_t N> |
| Tensor | to_assembly (const Tensor &from, const std::array< TensorShape, N > &intmd_shapes, const std::array< TensorShape, N > &base_shapes) |
| SparseTensorList | disassemble (const Tensor &, const std::optional< std::vector< TensorShape > > &intmd_shapes, const std::vector< TensorShape > &base_shapes) |
| Tensor | assemble (const SparseTensorList &, const std::optional< std::vector< TensorShape > > &intmd_shapes, const std::vector< TensorShape > &base_shapes) |
| SparseTensorList | disassemble (const Tensor &, const std::optional< std::vector< TensorShape > > &row_intmd_shapes, const std::optional< std::vector< TensorShape > > &col_intmd_shapes, const std::vector< TensorShape > &row_base_shapes, const std::vector< TensorShape > &col_base_shapes) |
| Tensor | assemble (const SparseTensorList &, const std::optional< std::vector< TensorShape > > &row_intmd_shapes, const std::optional< std::vector< TensorShape > > &col_intmd_shapes, const std::vector< TensorShape > &row_base_shapes, const std::vector< TensorShape > &col_base_shapes) |
| template<typename... Args> |
| void | neml_assert (bool assertion, Args &&... args) |
| template<typename... Args> |
| void | neml_assert_dbg (bool assertion, Args &&... args) |
| double | machine_precision (Dtype) |
| std::ostream & | operator<< (std::ostream &os, FType f) |
| std::tuple< Scalar, Scalar, Scalar > | parametric_coordinates (const Scalar &X, const Scalar &x) |
| template<typename T> |
| T | apply_mask (const T &a, const Scalar &m, std::size_t mdim) |
| bool & | currently_assembling_nonlinear_system () |
| std::ostream & | operator<< (std::ostream &os, const Model &model) |
| std::string | name (ElasticConstant p) |
| template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator+ (const T1 &a, const T2 &b) |
| template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator- (const T1 &a, const T2 &b) |
| template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator* (const T1 &a, const T2 &b) |
| template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator/ (const T1 &a, const T2 &b) |
| template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator> (const T1 &a, const T2 &b) |
| template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator< (const T1 &a, const T2 &b) |
| template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator>= (const T1 &a, const T2 &b) |
| template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator<= (const T1 &a, const T2 &b) |
| template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator&& (const T1 &a, const T2 &b) |
| template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator|| (const T1 &a, const T2 &b) |
| template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator== (const T1 &a, const T2 &b) |
| template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>> |
| auto | operator!= (const T1 &a, const T2 &b) |
| ValueMap | bind (const std::vector< VariableName > &, const std::vector< Tensor > &) |
| | Bind a vector of tensors to variable names.
|
| std::unique_ptr< Factory > | load_input (const std::filesystem::path &path, const std::string &additional_input="") |
| | A convenient function to parse all options from an input file.
|
| std::shared_ptr< Model > | load_model (const std::filesystem::path &path, const std::string &mname) |
| | A convenient function to load an input file and get a model.
|
| template<class... T> |
| void | neml_assert_broadcastable (const T &... tensors) |
| template<class... T> |
| void | neml_assert_dynamic_broadcastable (const T &... tensors) |
| template<class... T> |
| void | neml_assert_intmd_broadcastable (const T &... tensors) |
| template<class... T> |
| void | neml_assert_batch_broadcastable (const T &... tensors) |
| template<class... T> |
| void | neml_assert_base_broadcastable (const T &... tensors) |
| template<class... T> |
| void | neml_assert_static_broadcastable (const T &... tensors) |
| template<std::size_t N> |
| std::string | derivative_name (const std::string &var_name, const std::array< std::string, N > &arg_names) |
| | Pretty print derivative names.
|
| template<std::size_t N> |
| Tensor | fullify (const Tensor &t, Size iid, std::array< TensorShape, N > iiss) |
| Vec | abs (const Vec &a) |
| Rot | abs (const Rot &a) |
| WR2 | abs (const WR2 &a) |
| R2 | abs (const R2 &a) |
| SR2 | abs (const SR2 &a) |
| R3 | abs (const R3 &a) |
| SFR3 | abs (const SFR3 &a) |
| R4 | abs (const R4 &a) |
| SFFR4 | abs (const SFFR4 &a) |
| WFFR4 | abs (const WFFR4 &a) |
| SSR4 | abs (const SSR4 &a) |
| SWR4 | abs (const SWR4 &a) |
| WSR4 | abs (const WSR4 &a) |
| WWR4 | abs (const WWR4 &a) |
| Quaternion | abs (const Quaternion &a) |
| MillerIndex | abs (const MillerIndex &a) |
| Tensor | abs (const Tensor &a) |
| Scalar | abs (const Scalar &a) |
| Vec | acos (const Vec &a) |
| Rot | acos (const Rot &a) |
| WR2 | acos (const WR2 &a) |
| R2 | acos (const R2 &a) |
| SR2 | acos (const SR2 &a) |
| R3 | acos (const R3 &a) |
| SFR3 | acos (const SFR3 &a) |
| R4 | acos (const R4 &a) |
| SFFR4 | acos (const SFFR4 &a) |
| WFFR4 | acos (const WFFR4 &a) |
| SSR4 | acos (const SSR4 &a) |
| SWR4 | acos (const SWR4 &a) |
| WSR4 | acos (const WSR4 &a) |
| WWR4 | acos (const WWR4 &a) |
| Quaternion | acos (const Quaternion &a) |
| MillerIndex | acos (const MillerIndex &a) |
| Tensor | acos (const Tensor &a) |
| Scalar | acos (const Scalar &a) |
| Vec | dynamic_argmax (const Vec &a, Size dim) |
| Vec | intmd_argmax (const Vec &a, Size dim) |
| Vec | base_argmax (const Vec &a, Size dim) |
| Rot | dynamic_argmax (const Rot &a, Size dim) |
| Rot | intmd_argmax (const Rot &a, Size dim) |
| Rot | base_argmax (const Rot &a, Size dim) |
| WR2 | dynamic_argmax (const WR2 &a, Size dim) |
| WR2 | intmd_argmax (const WR2 &a, Size dim) |
| WR2 | base_argmax (const WR2 &a, Size dim) |
| R2 | dynamic_argmax (const R2 &a, Size dim) |
| R2 | intmd_argmax (const R2 &a, Size dim) |
| R2 | base_argmax (const R2 &a, Size dim) |
| SR2 | dynamic_argmax (const SR2 &a, Size dim) |
| SR2 | intmd_argmax (const SR2 &a, Size dim) |
| SR2 | base_argmax (const SR2 &a, Size dim) |
| R3 | dynamic_argmax (const R3 &a, Size dim) |
| R3 | intmd_argmax (const R3 &a, Size dim) |
| R3 | base_argmax (const R3 &a, Size dim) |
| SFR3 | dynamic_argmax (const SFR3 &a, Size dim) |
| SFR3 | intmd_argmax (const SFR3 &a, Size dim) |
| SFR3 | base_argmax (const SFR3 &a, Size dim) |
| R4 | dynamic_argmax (const R4 &a, Size dim) |
| R4 | intmd_argmax (const R4 &a, Size dim) |
| R4 | base_argmax (const R4 &a, Size dim) |
| SFFR4 | dynamic_argmax (const SFFR4 &a, Size dim) |
| SFFR4 | intmd_argmax (const SFFR4 &a, Size dim) |
| SFFR4 | base_argmax (const SFFR4 &a, Size dim) |
| WFFR4 | dynamic_argmax (const WFFR4 &a, Size dim) |
| WFFR4 | intmd_argmax (const WFFR4 &a, Size dim) |
| WFFR4 | base_argmax (const WFFR4 &a, Size dim) |
| SSR4 | dynamic_argmax (const SSR4 &a, Size dim) |
| SSR4 | intmd_argmax (const SSR4 &a, Size dim) |
| SSR4 | base_argmax (const SSR4 &a, Size dim) |
| SWR4 | dynamic_argmax (const SWR4 &a, Size dim) |
| SWR4 | intmd_argmax (const SWR4 &a, Size dim) |
| SWR4 | base_argmax (const SWR4 &a, Size dim) |
| WSR4 | dynamic_argmax (const WSR4 &a, Size dim) |
| WSR4 | intmd_argmax (const WSR4 &a, Size dim) |
| WSR4 | base_argmax (const WSR4 &a, Size dim) |
| WWR4 | dynamic_argmax (const WWR4 &a, Size dim) |
| WWR4 | intmd_argmax (const WWR4 &a, Size dim) |
| WWR4 | base_argmax (const WWR4 &a, Size dim) |
| Quaternion | dynamic_argmax (const Quaternion &a, Size dim) |
| Quaternion | intmd_argmax (const Quaternion &a, Size dim) |
| Quaternion | base_argmax (const Quaternion &a, Size dim) |
| MillerIndex | dynamic_argmax (const MillerIndex &a, Size dim) |
| MillerIndex | intmd_argmax (const MillerIndex &a, Size dim) |
| MillerIndex | base_argmax (const MillerIndex &a, Size dim) |
| Tensor | dynamic_argmax (const Tensor &a, Size dim) |
| Tensor | intmd_argmax (const Tensor &a, Size dim) |
| Tensor | base_argmax (const Tensor &a, Size dim) |
| Scalar | dynamic_argmax (const Scalar &a, Size dim) |
| Scalar | intmd_argmax (const Scalar &a, Size dim) |
| Scalar | base_argmax (const Scalar &a, Size dim) |
| Vec | dynamic_argmin (const Vec &a, Size dim) |
| Vec | intmd_argmin (const Vec &a, Size dim) |
| Vec | base_argmin (const Vec &a, Size dim) |
| Rot | dynamic_argmin (const Rot &a, Size dim) |
| Rot | intmd_argmin (const Rot &a, Size dim) |
| Rot | base_argmin (const Rot &a, Size dim) |
| WR2 | dynamic_argmin (const WR2 &a, Size dim) |
| WR2 | intmd_argmin (const WR2 &a, Size dim) |
| WR2 | base_argmin (const WR2 &a, Size dim) |
| R2 | dynamic_argmin (const R2 &a, Size dim) |
| R2 | intmd_argmin (const R2 &a, Size dim) |
| R2 | base_argmin (const R2 &a, Size dim) |
| SR2 | dynamic_argmin (const SR2 &a, Size dim) |
| SR2 | intmd_argmin (const SR2 &a, Size dim) |
| SR2 | base_argmin (const SR2 &a, Size dim) |
| R3 | dynamic_argmin (const R3 &a, Size dim) |
| R3 | intmd_argmin (const R3 &a, Size dim) |
| R3 | base_argmin (const R3 &a, Size dim) |
| SFR3 | dynamic_argmin (const SFR3 &a, Size dim) |
| SFR3 | intmd_argmin (const SFR3 &a, Size dim) |
| SFR3 | base_argmin (const SFR3 &a, Size dim) |
| R4 | dynamic_argmin (const R4 &a, Size dim) |
| R4 | intmd_argmin (const R4 &a, Size dim) |
| R4 | base_argmin (const R4 &a, Size dim) |
| SFFR4 | dynamic_argmin (const SFFR4 &a, Size dim) |
| SFFR4 | intmd_argmin (const SFFR4 &a, Size dim) |
| SFFR4 | base_argmin (const SFFR4 &a, Size dim) |
| WFFR4 | dynamic_argmin (const WFFR4 &a, Size dim) |
| WFFR4 | intmd_argmin (const WFFR4 &a, Size dim) |
| WFFR4 | base_argmin (const WFFR4 &a, Size dim) |
| SSR4 | dynamic_argmin (const SSR4 &a, Size dim) |
| SSR4 | intmd_argmin (const SSR4 &a, Size dim) |
| SSR4 | base_argmin (const SSR4 &a, Size dim) |
| SWR4 | dynamic_argmin (const SWR4 &a, Size dim) |
| SWR4 | intmd_argmin (const SWR4 &a, Size dim) |
| SWR4 | base_argmin (const SWR4 &a, Size dim) |
| WSR4 | dynamic_argmin (const WSR4 &a, Size dim) |
| WSR4 | intmd_argmin (const WSR4 &a, Size dim) |
| WSR4 | base_argmin (const WSR4 &a, Size dim) |
| WWR4 | dynamic_argmin (const WWR4 &a, Size dim) |
| WWR4 | intmd_argmin (const WWR4 &a, Size dim) |
| WWR4 | base_argmin (const WWR4 &a, Size dim) |
| Quaternion | dynamic_argmin (const Quaternion &a, Size dim) |
| Quaternion | intmd_argmin (const Quaternion &a, Size dim) |
| Quaternion | base_argmin (const Quaternion &a, Size dim) |
| MillerIndex | dynamic_argmin (const MillerIndex &a, Size dim) |
| MillerIndex | intmd_argmin (const MillerIndex &a, Size dim) |
| MillerIndex | base_argmin (const MillerIndex &a, Size dim) |
| Tensor | dynamic_argmin (const Tensor &a, Size dim) |
| Tensor | intmd_argmin (const Tensor &a, Size dim) |
| Tensor | base_argmin (const Tensor &a, Size dim) |
| Scalar | dynamic_argmin (const Scalar &a, Size dim) |
| Scalar | intmd_argmin (const Scalar &a, Size dim) |
| Scalar | base_argmin (const Scalar &a, Size dim) |
| Vec | asin (const Vec &a) |
| Rot | asin (const Rot &a) |
| WR2 | asin (const WR2 &a) |
| R2 | asin (const R2 &a) |
| SR2 | asin (const SR2 &a) |
| R3 | asin (const R3 &a) |
| SFR3 | asin (const SFR3 &a) |
| R4 | asin (const R4 &a) |
| SFFR4 | asin (const SFFR4 &a) |
| WFFR4 | asin (const WFFR4 &a) |
| SSR4 | asin (const SSR4 &a) |
| SWR4 | asin (const SWR4 &a) |
| WSR4 | asin (const WSR4 &a) |
| WWR4 | asin (const WWR4 &a) |
| Quaternion | asin (const Quaternion &a) |
| MillerIndex | asin (const MillerIndex &a) |
| Tensor | asin (const Tensor &a) |
| Scalar | asin (const Scalar &a) |
| Vec | atan (const Vec &a) |
| Rot | atan (const Rot &a) |
| WR2 | atan (const WR2 &a) |
| R2 | atan (const R2 &a) |
| SR2 | atan (const SR2 &a) |
| R3 | atan (const R3 &a) |
| SFR3 | atan (const SFR3 &a) |
| R4 | atan (const R4 &a) |
| SFFR4 | atan (const SFFR4 &a) |
| WFFR4 | atan (const WFFR4 &a) |
| SSR4 | atan (const SSR4 &a) |
| SWR4 | atan (const SWR4 &a) |
| WSR4 | atan (const WSR4 &a) |
| WWR4 | atan (const WWR4 &a) |
| Quaternion | atan (const Quaternion &a) |
| MillerIndex | atan (const MillerIndex &a) |
| Tensor | atan (const Tensor &a) |
| Scalar | atan (const Scalar &a) |
| Vec | atan2 (const Vec &a, const Vec &b) |
| Rot | atan2 (const Rot &a, const Rot &b) |
| WR2 | atan2 (const WR2 &a, const WR2 &b) |
| R2 | atan2 (const R2 &a, const R2 &b) |
| SR2 | atan2 (const SR2 &a, const SR2 &b) |
| R3 | atan2 (const R3 &a, const R3 &b) |
| SFR3 | atan2 (const SFR3 &a, const SFR3 &b) |
| R4 | atan2 (const R4 &a, const R4 &b) |
| SFFR4 | atan2 (const SFFR4 &a, const SFFR4 &b) |
| WFFR4 | atan2 (const WFFR4 &a, const WFFR4 &b) |
| SSR4 | atan2 (const SSR4 &a, const SSR4 &b) |
| SWR4 | atan2 (const SWR4 &a, const SWR4 &b) |
| WSR4 | atan2 (const WSR4 &a, const WSR4 &b) |
| WWR4 | atan2 (const WWR4 &a, const WWR4 &b) |
| Quaternion | atan2 (const Quaternion &a, const Quaternion &b) |
| MillerIndex | atan2 (const MillerIndex &a, const MillerIndex &b) |
| Tensor | atan2 (const Tensor &a, const Tensor &b) |
| Scalar | atan2 (const Scalar &a, const Scalar &b) |
| Vec | dynamic_cat (const std::vector< Vec > &tensors, Size d=0) |
| Vec | dynamic_cat (const std::initializer_list< Vec > &tensors, Size d=0) |
| Vec | intmd_cat (const std::vector< Vec > &tensors, Size d=0) |
| Vec | intmd_cat (const std::initializer_list< Vec > &tensors, Size d=0) |
| Rot | dynamic_cat (const std::vector< Rot > &tensors, Size d=0) |
| Rot | dynamic_cat (const std::initializer_list< Rot > &tensors, Size d=0) |
| Rot | intmd_cat (const std::vector< Rot > &tensors, Size d=0) |
| Rot | intmd_cat (const std::initializer_list< Rot > &tensors, Size d=0) |
| WR2 | dynamic_cat (const std::vector< WR2 > &tensors, Size d=0) |
| WR2 | dynamic_cat (const std::initializer_list< WR2 > &tensors, Size d=0) |
| WR2 | intmd_cat (const std::vector< WR2 > &tensors, Size d=0) |
| WR2 | intmd_cat (const std::initializer_list< WR2 > &tensors, Size d=0) |
| R2 | dynamic_cat (const std::vector< R2 > &tensors, Size d=0) |
| R2 | dynamic_cat (const std::initializer_list< R2 > &tensors, Size d=0) |
| R2 | intmd_cat (const std::vector< R2 > &tensors, Size d=0) |
| R2 | intmd_cat (const std::initializer_list< R2 > &tensors, Size d=0) |
| SR2 | dynamic_cat (const std::vector< SR2 > &tensors, Size d=0) |
| SR2 | dynamic_cat (const std::initializer_list< SR2 > &tensors, Size d=0) |
| SR2 | intmd_cat (const std::vector< SR2 > &tensors, Size d=0) |
| SR2 | intmd_cat (const std::initializer_list< SR2 > &tensors, Size d=0) |
| R3 | dynamic_cat (const std::vector< R3 > &tensors, Size d=0) |
| R3 | dynamic_cat (const std::initializer_list< R3 > &tensors, Size d=0) |
| R3 | intmd_cat (const std::vector< R3 > &tensors, Size d=0) |
| R3 | intmd_cat (const std::initializer_list< R3 > &tensors, Size d=0) |
| SFR3 | dynamic_cat (const std::vector< SFR3 > &tensors, Size d=0) |
| SFR3 | dynamic_cat (const std::initializer_list< SFR3 > &tensors, Size d=0) |
| SFR3 | intmd_cat (const std::vector< SFR3 > &tensors, Size d=0) |
| SFR3 | intmd_cat (const std::initializer_list< SFR3 > &tensors, Size d=0) |
| R4 | dynamic_cat (const std::vector< R4 > &tensors, Size d=0) |
| R4 | dynamic_cat (const std::initializer_list< R4 > &tensors, Size d=0) |
| R4 | intmd_cat (const std::vector< R4 > &tensors, Size d=0) |
| R4 | intmd_cat (const std::initializer_list< R4 > &tensors, Size d=0) |
| SFFR4 | dynamic_cat (const std::vector< SFFR4 > &tensors, Size d=0) |
| SFFR4 | dynamic_cat (const std::initializer_list< SFFR4 > &tensors, Size d=0) |
| SFFR4 | intmd_cat (const std::vector< SFFR4 > &tensors, Size d=0) |
| SFFR4 | intmd_cat (const std::initializer_list< SFFR4 > &tensors, Size d=0) |
| WFFR4 | dynamic_cat (const std::vector< WFFR4 > &tensors, Size d=0) |
| WFFR4 | dynamic_cat (const std::initializer_list< WFFR4 > &tensors, Size d=0) |
| WFFR4 | intmd_cat (const std::vector< WFFR4 > &tensors, Size d=0) |
| WFFR4 | intmd_cat (const std::initializer_list< WFFR4 > &tensors, Size d=0) |
| SSR4 | dynamic_cat (const std::vector< SSR4 > &tensors, Size d=0) |
| SSR4 | dynamic_cat (const std::initializer_list< SSR4 > &tensors, Size d=0) |
| SSR4 | intmd_cat (const std::vector< SSR4 > &tensors, Size d=0) |
| SSR4 | intmd_cat (const std::initializer_list< SSR4 > &tensors, Size d=0) |
| SWR4 | dynamic_cat (const std::vector< SWR4 > &tensors, Size d=0) |
| SWR4 | dynamic_cat (const std::initializer_list< SWR4 > &tensors, Size d=0) |
| SWR4 | intmd_cat (const std::vector< SWR4 > &tensors, Size d=0) |
| SWR4 | intmd_cat (const std::initializer_list< SWR4 > &tensors, Size d=0) |
| WSR4 | dynamic_cat (const std::vector< WSR4 > &tensors, Size d=0) |
| WSR4 | dynamic_cat (const std::initializer_list< WSR4 > &tensors, Size d=0) |
| WSR4 | intmd_cat (const std::vector< WSR4 > &tensors, Size d=0) |
| WSR4 | intmd_cat (const std::initializer_list< WSR4 > &tensors, Size d=0) |
| WWR4 | dynamic_cat (const std::vector< WWR4 > &tensors, Size d=0) |
| WWR4 | dynamic_cat (const std::initializer_list< WWR4 > &tensors, Size d=0) |
| WWR4 | intmd_cat (const std::vector< WWR4 > &tensors, Size d=0) |
| WWR4 | intmd_cat (const std::initializer_list< WWR4 > &tensors, Size d=0) |
| Quaternion | dynamic_cat (const std::vector< Quaternion > &tensors, Size d=0) |
| Quaternion | dynamic_cat (const std::initializer_list< Quaternion > &tensors, Size d=0) |
| Quaternion | intmd_cat (const std::vector< Quaternion > &tensors, Size d=0) |
| Quaternion | intmd_cat (const std::initializer_list< Quaternion > &tensors, Size d=0) |
| MillerIndex | dynamic_cat (const std::vector< MillerIndex > &tensors, Size d=0) |
| MillerIndex | dynamic_cat (const std::initializer_list< MillerIndex > &tensors, Size d=0) |
| MillerIndex | intmd_cat (const std::vector< MillerIndex > &tensors, Size d=0) |
| MillerIndex | intmd_cat (const std::initializer_list< MillerIndex > &tensors, Size d=0) |
| Tensor | dynamic_cat (const std::vector< Tensor > &tensors, Size d=0) |
| Tensor | dynamic_cat (const std::initializer_list< Tensor > &tensors, Size d=0) |
| Tensor | intmd_cat (const std::vector< Tensor > &tensors, Size d=0) |
| Tensor | intmd_cat (const std::initializer_list< Tensor > &tensors, Size d=0) |
| Scalar | dynamic_cat (const std::vector< Scalar > &tensors, Size d=0) |
| Scalar | dynamic_cat (const std::initializer_list< Scalar > &tensors, Size d=0) |
| Scalar | intmd_cat (const std::vector< Scalar > &tensors, Size d=0) |
| Scalar | intmd_cat (const std::initializer_list< Scalar > &tensors, Size d=0) |
| Tensor | base_cat (const std::vector< Tensor > &tensors, Size d=0) |
| Vec | cbrt (const Vec &a) |
| Rot | cbrt (const Rot &a) |
| WR2 | cbrt (const WR2 &a) |
| R2 | cbrt (const R2 &a) |
| SR2 | cbrt (const SR2 &a) |
| R3 | cbrt (const R3 &a) |
| SFR3 | cbrt (const SFR3 &a) |
| R4 | cbrt (const R4 &a) |
| SFFR4 | cbrt (const SFFR4 &a) |
| WFFR4 | cbrt (const WFFR4 &a) |
| SSR4 | cbrt (const SSR4 &a) |
| SWR4 | cbrt (const SWR4 &a) |
| WSR4 | cbrt (const WSR4 &a) |
| WWR4 | cbrt (const WWR4 &a) |
| Quaternion | cbrt (const Quaternion &a) |
| MillerIndex | cbrt (const MillerIndex &a) |
| Tensor | cbrt (const Tensor &a) |
| Scalar | cbrt (const Scalar &a) |
| Derivative< 1 > | chain_rule (const Derivative< 1 > &dy_du, const Derivative< 1 > &du_dx) |
| | Apply chain rule on two first-order derivatives.
|
| Derivative< 2 > | chain_rule (const Derivative< 2 > &d2y_du1u2, const Derivative< 1 > *du_dx1, const Derivative< 1 > *du_dx2) |
| Derivative< 2 > | chain_rule (const Derivative< 1 > &dy_du, const Derivative< 2 > &d2u_dx1x2) |
| Vec | clamp (const Vec &a, const Vec &lb, const Vec &ub) |
| Vec | clamp (const Vec &a, const CScalar &lb, const CScalar &ub) |
| Rot | clamp (const Rot &a, const Rot &lb, const Rot &ub) |
| Rot | clamp (const Rot &a, const CScalar &lb, const CScalar &ub) |
| WR2 | clamp (const WR2 &a, const WR2 &lb, const WR2 &ub) |
| WR2 | clamp (const WR2 &a, const CScalar &lb, const CScalar &ub) |
| R2 | clamp (const R2 &a, const R2 &lb, const R2 &ub) |
| R2 | clamp (const R2 &a, const CScalar &lb, const CScalar &ub) |
| SR2 | clamp (const SR2 &a, const SR2 &lb, const SR2 &ub) |
| SR2 | clamp (const SR2 &a, const CScalar &lb, const CScalar &ub) |
| R3 | clamp (const R3 &a, const R3 &lb, const R3 &ub) |
| R3 | clamp (const R3 &a, const CScalar &lb, const CScalar &ub) |
| SFR3 | clamp (const SFR3 &a, const SFR3 &lb, const SFR3 &ub) |
| SFR3 | clamp (const SFR3 &a, const CScalar &lb, const CScalar &ub) |
| R4 | clamp (const R4 &a, const R4 &lb, const R4 &ub) |
| R4 | clamp (const R4 &a, const CScalar &lb, const CScalar &ub) |
| SFFR4 | clamp (const SFFR4 &a, const SFFR4 &lb, const SFFR4 &ub) |
| SFFR4 | clamp (const SFFR4 &a, const CScalar &lb, const CScalar &ub) |
| WFFR4 | clamp (const WFFR4 &a, const WFFR4 &lb, const WFFR4 &ub) |
| WFFR4 | clamp (const WFFR4 &a, const CScalar &lb, const CScalar &ub) |
| SSR4 | clamp (const SSR4 &a, const SSR4 &lb, const SSR4 &ub) |
| SSR4 | clamp (const SSR4 &a, const CScalar &lb, const CScalar &ub) |
| SWR4 | clamp (const SWR4 &a, const SWR4 &lb, const SWR4 &ub) |
| SWR4 | clamp (const SWR4 &a, const CScalar &lb, const CScalar &ub) |
| WSR4 | clamp (const WSR4 &a, const WSR4 &lb, const WSR4 &ub) |
| WSR4 | clamp (const WSR4 &a, const CScalar &lb, const CScalar &ub) |
| WWR4 | clamp (const WWR4 &a, const WWR4 &lb, const WWR4 &ub) |
| WWR4 | clamp (const WWR4 &a, const CScalar &lb, const CScalar &ub) |
| Quaternion | clamp (const Quaternion &a, const Quaternion &lb, const Quaternion &ub) |
| Quaternion | clamp (const Quaternion &a, const CScalar &lb, const CScalar &ub) |
| MillerIndex | clamp (const MillerIndex &a, const MillerIndex &lb, const MillerIndex &ub) |
| MillerIndex | clamp (const MillerIndex &a, const CScalar &lb, const CScalar &ub) |
| Tensor | clamp (const Tensor &a, const Tensor &lb, const Tensor &ub) |
| Tensor | clamp (const Tensor &a, const CScalar &lb, const CScalar &ub) |
| Scalar | clamp (const Scalar &a, const Scalar &lb, const Scalar &ub) |
| Scalar | clamp (const Scalar &a, const CScalar &lb, const CScalar &ub) |
| Vec | clip (const Vec &a, const Vec &lb, const Vec &ub) |
| Vec | clip (const Vec &a, const CScalar &lb, const CScalar &ub) |
| Rot | clip (const Rot &a, const Rot &lb, const Rot &ub) |
| Rot | clip (const Rot &a, const CScalar &lb, const CScalar &ub) |
| WR2 | clip (const WR2 &a, const WR2 &lb, const WR2 &ub) |
| WR2 | clip (const WR2 &a, const CScalar &lb, const CScalar &ub) |
| R2 | clip (const R2 &a, const R2 &lb, const R2 &ub) |
| R2 | clip (const R2 &a, const CScalar &lb, const CScalar &ub) |
| SR2 | clip (const SR2 &a, const SR2 &lb, const SR2 &ub) |
| SR2 | clip (const SR2 &a, const CScalar &lb, const CScalar &ub) |
| R3 | clip (const R3 &a, const R3 &lb, const R3 &ub) |
| R3 | clip (const R3 &a, const CScalar &lb, const CScalar &ub) |
| SFR3 | clip (const SFR3 &a, const SFR3 &lb, const SFR3 &ub) |
| SFR3 | clip (const SFR3 &a, const CScalar &lb, const CScalar &ub) |
| R4 | clip (const R4 &a, const R4 &lb, const R4 &ub) |
| R4 | clip (const R4 &a, const CScalar &lb, const CScalar &ub) |
| SFFR4 | clip (const SFFR4 &a, const SFFR4 &lb, const SFFR4 &ub) |
| SFFR4 | clip (const SFFR4 &a, const CScalar &lb, const CScalar &ub) |
| WFFR4 | clip (const WFFR4 &a, const WFFR4 &lb, const WFFR4 &ub) |
| WFFR4 | clip (const WFFR4 &a, const CScalar &lb, const CScalar &ub) |
| SSR4 | clip (const SSR4 &a, const SSR4 &lb, const SSR4 &ub) |
| SSR4 | clip (const SSR4 &a, const CScalar &lb, const CScalar &ub) |
| SWR4 | clip (const SWR4 &a, const SWR4 &lb, const SWR4 &ub) |
| SWR4 | clip (const SWR4 &a, const CScalar &lb, const CScalar &ub) |
| WSR4 | clip (const WSR4 &a, const WSR4 &lb, const WSR4 &ub) |
| WSR4 | clip (const WSR4 &a, const CScalar &lb, const CScalar &ub) |
| WWR4 | clip (const WWR4 &a, const WWR4 &lb, const WWR4 &ub) |
| WWR4 | clip (const WWR4 &a, const CScalar &lb, const CScalar &ub) |
| Quaternion | clip (const Quaternion &a, const Quaternion &lb, const Quaternion &ub) |
| Quaternion | clip (const Quaternion &a, const CScalar &lb, const CScalar &ub) |
| MillerIndex | clip (const MillerIndex &a, const MillerIndex &lb, const MillerIndex &ub) |
| MillerIndex | clip (const MillerIndex &a, const CScalar &lb, const CScalar &ub) |
| Tensor | clip (const Tensor &a, const Tensor &lb, const Tensor &ub) |
| Tensor | clip (const Tensor &a, const CScalar &lb, const CScalar &ub) |
| Scalar | clip (const Scalar &a, const Scalar &lb, const Scalar &ub) |
| Scalar | clip (const Scalar &a, const CScalar &lb, const CScalar &ub) |
| Vec | cos (const Vec &a) |
| Rot | cos (const Rot &a) |
| WR2 | cos (const WR2 &a) |
| R2 | cos (const R2 &a) |
| SR2 | cos (const SR2 &a) |
| R3 | cos (const R3 &a) |
| SFR3 | cos (const SFR3 &a) |
| R4 | cos (const R4 &a) |
| SFFR4 | cos (const SFFR4 &a) |
| WFFR4 | cos (const WFFR4 &a) |
| SSR4 | cos (const SSR4 &a) |
| SWR4 | cos (const SWR4 &a) |
| WSR4 | cos (const WSR4 &a) |
| WWR4 | cos (const WWR4 &a) |
| Quaternion | cos (const Quaternion &a) |
| MillerIndex | cos (const MillerIndex &a) |
| Tensor | cos (const Tensor &a) |
| Scalar | cos (const Scalar &a) |
| Vec | cosh (const Vec &a) |
| Rot | cosh (const Rot &a) |
| WR2 | cosh (const WR2 &a) |
| R2 | cosh (const R2 &a) |
| SR2 | cosh (const SR2 &a) |
| R3 | cosh (const R3 &a) |
| SFR3 | cosh (const SFR3 &a) |
| R4 | cosh (const R4 &a) |
| SFFR4 | cosh (const SFFR4 &a) |
| WFFR4 | cosh (const WFFR4 &a) |
| SSR4 | cosh (const SSR4 &a) |
| SWR4 | cosh (const SWR4 &a) |
| WSR4 | cosh (const WSR4 &a) |
| WWR4 | cosh (const WWR4 &a) |
| Quaternion | cosh (const Quaternion &a) |
| MillerIndex | cosh (const MillerIndex &a) |
| Tensor | cosh (const Tensor &a) |
| Scalar | cosh (const Scalar &a) |
| Vec | cross (const Vec &u, const Vec &v) |
| Vec | deg2rad (const Vec &a) |
| Rot | deg2rad (const Rot &a) |
| WR2 | deg2rad (const WR2 &a) |
| R2 | deg2rad (const R2 &a) |
| SR2 | deg2rad (const SR2 &a) |
| R3 | deg2rad (const R3 &a) |
| SFR3 | deg2rad (const SFR3 &a) |
| R4 | deg2rad (const R4 &a) |
| SFFR4 | deg2rad (const SFFR4 &a) |
| WFFR4 | deg2rad (const WFFR4 &a) |
| SSR4 | deg2rad (const SSR4 &a) |
| SWR4 | deg2rad (const SWR4 &a) |
| WSR4 | deg2rad (const WSR4 &a) |
| WWR4 | deg2rad (const WWR4 &a) |
| Quaternion | deg2rad (const Quaternion &a) |
| MillerIndex | deg2rad (const MillerIndex &a) |
| Tensor | deg2rad (const Tensor &a) |
| Scalar | deg2rad (const Scalar &a) |
| Vec | dynamic_diagonalize (const Vec &a, Size d=-1) |
| Vec | intmd_diagonalize (const Vec &a, Size d=-1) |
| Rot | dynamic_diagonalize (const Rot &a, Size d=-1) |
| Rot | intmd_diagonalize (const Rot &a, Size d=-1) |
| WR2 | dynamic_diagonalize (const WR2 &a, Size d=-1) |
| WR2 | intmd_diagonalize (const WR2 &a, Size d=-1) |
| R2 | dynamic_diagonalize (const R2 &a, Size d=-1) |
| R2 | intmd_diagonalize (const R2 &a, Size d=-1) |
| SR2 | dynamic_diagonalize (const SR2 &a, Size d=-1) |
| SR2 | intmd_diagonalize (const SR2 &a, Size d=-1) |
| R3 | dynamic_diagonalize (const R3 &a, Size d=-1) |
| R3 | intmd_diagonalize (const R3 &a, Size d=-1) |
| SFR3 | dynamic_diagonalize (const SFR3 &a, Size d=-1) |
| SFR3 | intmd_diagonalize (const SFR3 &a, Size d=-1) |
| R4 | dynamic_diagonalize (const R4 &a, Size d=-1) |
| R4 | intmd_diagonalize (const R4 &a, Size d=-1) |
| SFFR4 | dynamic_diagonalize (const SFFR4 &a, Size d=-1) |
| SFFR4 | intmd_diagonalize (const SFFR4 &a, Size d=-1) |
| WFFR4 | dynamic_diagonalize (const WFFR4 &a, Size d=-1) |
| WFFR4 | intmd_diagonalize (const WFFR4 &a, Size d=-1) |
| SSR4 | dynamic_diagonalize (const SSR4 &a, Size d=-1) |
| SSR4 | intmd_diagonalize (const SSR4 &a, Size d=-1) |
| SWR4 | dynamic_diagonalize (const SWR4 &a, Size d=-1) |
| SWR4 | intmd_diagonalize (const SWR4 &a, Size d=-1) |
| WSR4 | dynamic_diagonalize (const WSR4 &a, Size d=-1) |
| WSR4 | intmd_diagonalize (const WSR4 &a, Size d=-1) |
| WWR4 | dynamic_diagonalize (const WWR4 &a, Size d=-1) |
| WWR4 | intmd_diagonalize (const WWR4 &a, Size d=-1) |
| Quaternion | dynamic_diagonalize (const Quaternion &a, Size d=-1) |
| Quaternion | intmd_diagonalize (const Quaternion &a, Size d=-1) |
| MillerIndex | dynamic_diagonalize (const MillerIndex &a, Size d=-1) |
| MillerIndex | intmd_diagonalize (const MillerIndex &a, Size d=-1) |
| Tensor | dynamic_diagonalize (const Tensor &a, Size d=-1) |
| Tensor | intmd_diagonalize (const Tensor &a, Size d=-1) |
| Scalar | dynamic_diagonalize (const Scalar &a, Size d=-1) |
| Scalar | intmd_diagonalize (const Scalar &a, Size d=-1) |
| Tensor | base_diagonalize (const Tensor &a, Size d=-1) |
| Vec | dynamic_diff (const Vec &a, Size n=1, Size dim=-1) |
| Vec | intmd_diff (const Vec &a, Size n=1, Size dim=-1) |
| Rot | dynamic_diff (const Rot &a, Size n=1, Size dim=-1) |
| Rot | intmd_diff (const Rot &a, Size n=1, Size dim=-1) |
| WR2 | dynamic_diff (const WR2 &a, Size n=1, Size dim=-1) |
| WR2 | intmd_diff (const WR2 &a, Size n=1, Size dim=-1) |
| R2 | dynamic_diff (const R2 &a, Size n=1, Size dim=-1) |
| R2 | intmd_diff (const R2 &a, Size n=1, Size dim=-1) |
| SR2 | dynamic_diff (const SR2 &a, Size n=1, Size dim=-1) |
| SR2 | intmd_diff (const SR2 &a, Size n=1, Size dim=-1) |
| R3 | dynamic_diff (const R3 &a, Size n=1, Size dim=-1) |
| R3 | intmd_diff (const R3 &a, Size n=1, Size dim=-1) |
| SFR3 | dynamic_diff (const SFR3 &a, Size n=1, Size dim=-1) |
| SFR3 | intmd_diff (const SFR3 &a, Size n=1, Size dim=-1) |
| R4 | dynamic_diff (const R4 &a, Size n=1, Size dim=-1) |
| R4 | intmd_diff (const R4 &a, Size n=1, Size dim=-1) |
| SFFR4 | dynamic_diff (const SFFR4 &a, Size n=1, Size dim=-1) |
| SFFR4 | intmd_diff (const SFFR4 &a, Size n=1, Size dim=-1) |
| WFFR4 | dynamic_diff (const WFFR4 &a, Size n=1, Size dim=-1) |
| WFFR4 | intmd_diff (const WFFR4 &a, Size n=1, Size dim=-1) |
| SSR4 | dynamic_diff (const SSR4 &a, Size n=1, Size dim=-1) |
| SSR4 | intmd_diff (const SSR4 &a, Size n=1, Size dim=-1) |
| SWR4 | dynamic_diff (const SWR4 &a, Size n=1, Size dim=-1) |
| SWR4 | intmd_diff (const SWR4 &a, Size n=1, Size dim=-1) |
| WSR4 | dynamic_diff (const WSR4 &a, Size n=1, Size dim=-1) |
| WSR4 | intmd_diff (const WSR4 &a, Size n=1, Size dim=-1) |
| WWR4 | dynamic_diff (const WWR4 &a, Size n=1, Size dim=-1) |
| WWR4 | intmd_diff (const WWR4 &a, Size n=1, Size dim=-1) |
| Quaternion | dynamic_diff (const Quaternion &a, Size n=1, Size dim=-1) |
| Quaternion | intmd_diff (const Quaternion &a, Size n=1, Size dim=-1) |
| MillerIndex | dynamic_diff (const MillerIndex &a, Size n=1, Size dim=-1) |
| MillerIndex | intmd_diff (const MillerIndex &a, Size n=1, Size dim=-1) |
| Tensor | dynamic_diff (const Tensor &a, Size n=1, Size dim=-1) |
| Tensor | intmd_diff (const Tensor &a, Size n=1, Size dim=-1) |
| Scalar | dynamic_diff (const Scalar &a, Size n=1, Size dim=-1) |
| Scalar | intmd_diff (const Scalar &a, Size n=1, Size dim=-1) |
| neml2::Tensor | base_diff (const Tensor &a, Size n=1, Size dim=-1) |
| Tensor | einsum (c10::string_view equation, TensorList tensors) |
| | Einstein summation along base dimensions.
|
| Vec | exp (const Vec &a) |
| Rot | exp (const Rot &a) |
| WR2 | exp (const WR2 &a) |
| R2 | exp (const R2 &a) |
| SR2 | exp (const SR2 &a) |
| R3 | exp (const R3 &a) |
| SFR3 | exp (const SFR3 &a) |
| R4 | exp (const R4 &a) |
| SFFR4 | exp (const SFFR4 &a) |
| WFFR4 | exp (const WFFR4 &a) |
| SSR4 | exp (const SSR4 &a) |
| SWR4 | exp (const SWR4 &a) |
| WSR4 | exp (const WSR4 &a) |
| WWR4 | exp (const WWR4 &a) |
| Quaternion | exp (const Quaternion &a) |
| MillerIndex | exp (const MillerIndex &a) |
| Tensor | exp (const Tensor &a) |
| Scalar | exp (const Scalar &a) |
| Vec | fmod (const Vec &a, const Vec &b) |
| Vec | fmod (const Vec &a, const CScalar &b) |
| Rot | fmod (const Rot &a, const Rot &b) |
| Rot | fmod (const Rot &a, const CScalar &b) |
| WR2 | fmod (const WR2 &a, const WR2 &b) |
| WR2 | fmod (const WR2 &a, const CScalar &b) |
| R2 | fmod (const R2 &a, const R2 &b) |
| R2 | fmod (const R2 &a, const CScalar &b) |
| SR2 | fmod (const SR2 &a, const SR2 &b) |
| SR2 | fmod (const SR2 &a, const CScalar &b) |
| R3 | fmod (const R3 &a, const R3 &b) |
| R3 | fmod (const R3 &a, const CScalar &b) |
| SFR3 | fmod (const SFR3 &a, const SFR3 &b) |
| SFR3 | fmod (const SFR3 &a, const CScalar &b) |
| R4 | fmod (const R4 &a, const R4 &b) |
| R4 | fmod (const R4 &a, const CScalar &b) |
| SFFR4 | fmod (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | fmod (const SFFR4 &a, const CScalar &b) |
| WFFR4 | fmod (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | fmod (const WFFR4 &a, const CScalar &b) |
| SSR4 | fmod (const SSR4 &a, const SSR4 &b) |
| SSR4 | fmod (const SSR4 &a, const CScalar &b) |
| SWR4 | fmod (const SWR4 &a, const SWR4 &b) |
| SWR4 | fmod (const SWR4 &a, const CScalar &b) |
| WSR4 | fmod (const WSR4 &a, const WSR4 &b) |
| WSR4 | fmod (const WSR4 &a, const CScalar &b) |
| WWR4 | fmod (const WWR4 &a, const WWR4 &b) |
| WWR4 | fmod (const WWR4 &a, const CScalar &b) |
| Quaternion | fmod (const Quaternion &a, const Quaternion &b) |
| Quaternion | fmod (const Quaternion &a, const CScalar &b) |
| MillerIndex | fmod (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | fmod (const MillerIndex &a, const CScalar &b) |
| Tensor | fmod (const Tensor &a, const Tensor &b) |
| Tensor | fmod (const Tensor &a, const CScalar &b) |
| Scalar | fmod (const Scalar &a, const Scalar &b) |
| Scalar | fmod (const Scalar &a, const CScalar &b) |
| Vec | gcd (const Vec &a, const Vec &b) |
| Rot | gcd (const Rot &a, const Rot &b) |
| WR2 | gcd (const WR2 &a, const WR2 &b) |
| R2 | gcd (const R2 &a, const R2 &b) |
| SR2 | gcd (const SR2 &a, const SR2 &b) |
| R3 | gcd (const R3 &a, const R3 &b) |
| SFR3 | gcd (const SFR3 &a, const SFR3 &b) |
| R4 | gcd (const R4 &a, const R4 &b) |
| SFFR4 | gcd (const SFFR4 &a, const SFFR4 &b) |
| WFFR4 | gcd (const WFFR4 &a, const WFFR4 &b) |
| SSR4 | gcd (const SSR4 &a, const SSR4 &b) |
| SWR4 | gcd (const SWR4 &a, const SWR4 &b) |
| WSR4 | gcd (const WSR4 &a, const WSR4 &b) |
| WWR4 | gcd (const WWR4 &a, const WWR4 &b) |
| Quaternion | gcd (const Quaternion &a, const Quaternion &b) |
| MillerIndex | gcd (const MillerIndex &a, const MillerIndex &b) |
| Tensor | gcd (const Tensor &a, const Tensor &b) |
| Scalar | gcd (const Scalar &a, const Scalar &b) |
| Vec | heaviside (const Vec &a) |
| Rot | heaviside (const Rot &a) |
| WR2 | heaviside (const WR2 &a) |
| R2 | heaviside (const R2 &a) |
| SR2 | heaviside (const SR2 &a) |
| R3 | heaviside (const R3 &a) |
| SFR3 | heaviside (const SFR3 &a) |
| R4 | heaviside (const R4 &a) |
| SFFR4 | heaviside (const SFFR4 &a) |
| WFFR4 | heaviside (const WFFR4 &a) |
| SSR4 | heaviside (const SSR4 &a) |
| SWR4 | heaviside (const SWR4 &a) |
| WSR4 | heaviside (const WSR4 &a) |
| WWR4 | heaviside (const WWR4 &a) |
| Quaternion | heaviside (const Quaternion &a) |
| MillerIndex | heaviside (const MillerIndex &a) |
| Tensor | heaviside (const Tensor &a) |
| Scalar | heaviside (const Scalar &a) |
| template<typename T> |
| DTensor< T, T, typename imap_t< T >::type > | imap (const TensorOptions &options=default_tensor_options()) |
| | Identity map.
|
| template<typename T> |
| imap_t< T >::type | imap_v (const TensorOptions &options=default_tensor_options()) |
| | Get the identity map interpreted as the concrete primitive tensor type.
|
| template<> |
| DTensor< Scalar, Scalar, typename imap_t< Scalar >::type > | imap (const TensorOptions &options) |
| template<> |
| DTensor< Vec, Vec, typename imap_t< Vec >::type > | imap (const TensorOptions &options) |
| template<> |
| DTensor< R2, R2, typename imap_t< R2 >::type > | imap (const TensorOptions &options) |
| template<> |
| DTensor< SR2, SR2, typename imap_t< SR2 >::type > | imap (const TensorOptions &options) |
| template<> |
| DTensor< SSR4, SSR4, typename imap_t< SSR4 >::type > | imap (const TensorOptions &options) |
| Scalar | inner (const Tensor &a, const Tensor &b) |
| | Inner product.
|
| Tensor | inv (const Tensor &) |
| | Inverse of a second order or fourth order tensor.
|
| Rot | inv (const Rot &) |
| | Inverse of a rotation (MRP).
|
| std::vector< Tensor > | jacrev (const Tensor &y, const std::vector< Tensor > &xs, bool retain_graph=false, bool create_graph=false, bool allow_unused=false) |
| | Use automatic differentiation (AD) to calculate the derivatives of a Tensor w.r.t. another Tensor.
|
| Tensor | jacrev (const Tensor &y, const Tensor &x, bool retain_graph=false, bool create_graph=false, bool allow_unused=false) |
| | Similar to the other jacrev, but for a single input.
|
| Vec | log (const Vec &a) |
| Rot | log (const Rot &a) |
| WR2 | log (const WR2 &a) |
| R2 | log (const R2 &a) |
| SR2 | log (const SR2 &a) |
| R3 | log (const R3 &a) |
| SFR3 | log (const SFR3 &a) |
| R4 | log (const R4 &a) |
| SFFR4 | log (const SFFR4 &a) |
| WFFR4 | log (const WFFR4 &a) |
| SSR4 | log (const SSR4 &a) |
| SWR4 | log (const SWR4 &a) |
| WSR4 | log (const WSR4 &a) |
| WWR4 | log (const WWR4 &a) |
| Quaternion | log (const Quaternion &a) |
| MillerIndex | log (const MillerIndex &a) |
| Tensor | log (const Tensor &a) |
| Scalar | log (const Scalar &a) |
| Vec | log10 (const Vec &a) |
| Rot | log10 (const Rot &a) |
| WR2 | log10 (const WR2 &a) |
| R2 | log10 (const R2 &a) |
| SR2 | log10 (const SR2 &a) |
| R3 | log10 (const R3 &a) |
| SFR3 | log10 (const SFR3 &a) |
| R4 | log10 (const R4 &a) |
| SFFR4 | log10 (const SFFR4 &a) |
| WFFR4 | log10 (const WFFR4 &a) |
| SSR4 | log10 (const SSR4 &a) |
| SWR4 | log10 (const SWR4 &a) |
| WSR4 | log10 (const WSR4 &a) |
| WWR4 | log10 (const WWR4 &a) |
| Quaternion | log10 (const Quaternion &a) |
| MillerIndex | log10 (const MillerIndex &a) |
| Tensor | log10 (const Tensor &a) |
| Scalar | log10 (const Scalar &a) |
| Vec | operator> (const Vec &a, const Vec &b) |
| Vec | operator< (const Vec &a, const Vec &b) |
| Vec | operator>= (const Vec &a, const Vec &b) |
| Vec | operator<= (const Vec &a, const Vec &b) |
| Vec | operator&& (const Vec &a, const Vec &b) |
| Vec | operator|| (const Vec &a, const Vec &b) |
| Vec | operator== (const Vec &a, const Vec &b) |
| Vec | operator!= (const Vec &a, const Vec &b) |
| Vec | gt (const Vec &a, const Vec &b) |
| Vec | lt (const Vec &a, const Vec &b) |
| Vec | ge (const Vec &a, const Vec &b) |
| Vec | le (const Vec &a, const Vec &b) |
| Vec | logical_and (const Vec &a, const Vec &b) |
| Vec | logical_or (const Vec &a, const Vec &b) |
| Vec | logical_xor (const Vec &a, const Vec &b) |
| Vec | eq (const Vec &a, const Vec &b) |
| Vec | ne (const Vec &a, const Vec &b) |
| Vec | operator! (const Vec &a) |
| Vec | logical_not (const Vec &a) |
| Rot | operator> (const Rot &a, const Rot &b) |
| Rot | operator< (const Rot &a, const Rot &b) |
| Rot | operator>= (const Rot &a, const Rot &b) |
| Rot | operator<= (const Rot &a, const Rot &b) |
| Rot | operator&& (const Rot &a, const Rot &b) |
| Rot | operator|| (const Rot &a, const Rot &b) |
| Rot | operator== (const Rot &a, const Rot &b) |
| Rot | operator!= (const Rot &a, const Rot &b) |
| Rot | gt (const Rot &a, const Rot &b) |
| Rot | lt (const Rot &a, const Rot &b) |
| Rot | ge (const Rot &a, const Rot &b) |
| Rot | le (const Rot &a, const Rot &b) |
| Rot | logical_and (const Rot &a, const Rot &b) |
| Rot | logical_or (const Rot &a, const Rot &b) |
| Rot | logical_xor (const Rot &a, const Rot &b) |
| Rot | eq (const Rot &a, const Rot &b) |
| Rot | ne (const Rot &a, const Rot &b) |
| Rot | operator! (const Rot &a) |
| Rot | logical_not (const Rot &a) |
| WR2 | operator> (const WR2 &a, const WR2 &b) |
| WR2 | operator< (const WR2 &a, const WR2 &b) |
| WR2 | operator>= (const WR2 &a, const WR2 &b) |
| WR2 | operator<= (const WR2 &a, const WR2 &b) |
| WR2 | operator&& (const WR2 &a, const WR2 &b) |
| WR2 | operator|| (const WR2 &a, const WR2 &b) |
| WR2 | operator== (const WR2 &a, const WR2 &b) |
| WR2 | operator!= (const WR2 &a, const WR2 &b) |
| WR2 | gt (const WR2 &a, const WR2 &b) |
| WR2 | lt (const WR2 &a, const WR2 &b) |
| WR2 | ge (const WR2 &a, const WR2 &b) |
| WR2 | le (const WR2 &a, const WR2 &b) |
| WR2 | logical_and (const WR2 &a, const WR2 &b) |
| WR2 | logical_or (const WR2 &a, const WR2 &b) |
| WR2 | logical_xor (const WR2 &a, const WR2 &b) |
| WR2 | eq (const WR2 &a, const WR2 &b) |
| WR2 | ne (const WR2 &a, const WR2 &b) |
| WR2 | operator! (const WR2 &a) |
| WR2 | logical_not (const WR2 &a) |
| R2 | operator> (const R2 &a, const R2 &b) |
| R2 | operator< (const R2 &a, const R2 &b) |
| R2 | operator>= (const R2 &a, const R2 &b) |
| R2 | operator<= (const R2 &a, const R2 &b) |
| R2 | operator&& (const R2 &a, const R2 &b) |
| R2 | operator|| (const R2 &a, const R2 &b) |
| R2 | operator== (const R2 &a, const R2 &b) |
| R2 | operator!= (const R2 &a, const R2 &b) |
| R2 | gt (const R2 &a, const R2 &b) |
| R2 | lt (const R2 &a, const R2 &b) |
| R2 | ge (const R2 &a, const R2 &b) |
| R2 | le (const R2 &a, const R2 &b) |
| R2 | logical_and (const R2 &a, const R2 &b) |
| R2 | logical_or (const R2 &a, const R2 &b) |
| R2 | logical_xor (const R2 &a, const R2 &b) |
| R2 | eq (const R2 &a, const R2 &b) |
| R2 | ne (const R2 &a, const R2 &b) |
| R2 | operator! (const R2 &a) |
| R2 | logical_not (const R2 &a) |
| SR2 | operator> (const SR2 &a, const SR2 &b) |
| SR2 | operator< (const SR2 &a, const SR2 &b) |
| SR2 | operator>= (const SR2 &a, const SR2 &b) |
| SR2 | operator<= (const SR2 &a, const SR2 &b) |
| SR2 | operator&& (const SR2 &a, const SR2 &b) |
| SR2 | operator|| (const SR2 &a, const SR2 &b) |
| SR2 | operator== (const SR2 &a, const SR2 &b) |
| SR2 | operator!= (const SR2 &a, const SR2 &b) |
| SR2 | gt (const SR2 &a, const SR2 &b) |
| SR2 | lt (const SR2 &a, const SR2 &b) |
| SR2 | ge (const SR2 &a, const SR2 &b) |
| SR2 | le (const SR2 &a, const SR2 &b) |
| SR2 | logical_and (const SR2 &a, const SR2 &b) |
| SR2 | logical_or (const SR2 &a, const SR2 &b) |
| SR2 | logical_xor (const SR2 &a, const SR2 &b) |
| SR2 | eq (const SR2 &a, const SR2 &b) |
| SR2 | ne (const SR2 &a, const SR2 &b) |
| SR2 | operator! (const SR2 &a) |
| SR2 | logical_not (const SR2 &a) |
| R3 | operator> (const R3 &a, const R3 &b) |
| R3 | operator< (const R3 &a, const R3 &b) |
| R3 | operator>= (const R3 &a, const R3 &b) |
| R3 | operator<= (const R3 &a, const R3 &b) |
| R3 | operator&& (const R3 &a, const R3 &b) |
| R3 | operator|| (const R3 &a, const R3 &b) |
| R3 | operator== (const R3 &a, const R3 &b) |
| R3 | operator!= (const R3 &a, const R3 &b) |
| R3 | gt (const R3 &a, const R3 &b) |
| R3 | lt (const R3 &a, const R3 &b) |
| R3 | ge (const R3 &a, const R3 &b) |
| R3 | le (const R3 &a, const R3 &b) |
| R3 | logical_and (const R3 &a, const R3 &b) |
| R3 | logical_or (const R3 &a, const R3 &b) |
| R3 | logical_xor (const R3 &a, const R3 &b) |
| R3 | eq (const R3 &a, const R3 &b) |
| R3 | ne (const R3 &a, const R3 &b) |
| R3 | operator! (const R3 &a) |
| R3 | logical_not (const R3 &a) |
| SFR3 | operator> (const SFR3 &a, const SFR3 &b) |
| SFR3 | operator< (const SFR3 &a, const SFR3 &b) |
| SFR3 | operator>= (const SFR3 &a, const SFR3 &b) |
| SFR3 | operator<= (const SFR3 &a, const SFR3 &b) |
| SFR3 | operator&& (const SFR3 &a, const SFR3 &b) |
| SFR3 | operator|| (const SFR3 &a, const SFR3 &b) |
| SFR3 | operator== (const SFR3 &a, const SFR3 &b) |
| SFR3 | operator!= (const SFR3 &a, const SFR3 &b) |
| SFR3 | gt (const SFR3 &a, const SFR3 &b) |
| SFR3 | lt (const SFR3 &a, const SFR3 &b) |
| SFR3 | ge (const SFR3 &a, const SFR3 &b) |
| SFR3 | le (const SFR3 &a, const SFR3 &b) |
| SFR3 | logical_and (const SFR3 &a, const SFR3 &b) |
| SFR3 | logical_or (const SFR3 &a, const SFR3 &b) |
| SFR3 | logical_xor (const SFR3 &a, const SFR3 &b) |
| SFR3 | eq (const SFR3 &a, const SFR3 &b) |
| SFR3 | ne (const SFR3 &a, const SFR3 &b) |
| SFR3 | operator! (const SFR3 &a) |
| SFR3 | logical_not (const SFR3 &a) |
| R4 | operator> (const R4 &a, const R4 &b) |
| R4 | operator< (const R4 &a, const R4 &b) |
| R4 | operator>= (const R4 &a, const R4 &b) |
| R4 | operator<= (const R4 &a, const R4 &b) |
| R4 | operator&& (const R4 &a, const R4 &b) |
| R4 | operator|| (const R4 &a, const R4 &b) |
| R4 | operator== (const R4 &a, const R4 &b) |
| R4 | operator!= (const R4 &a, const R4 &b) |
| R4 | gt (const R4 &a, const R4 &b) |
| R4 | lt (const R4 &a, const R4 &b) |
| R4 | ge (const R4 &a, const R4 &b) |
| R4 | le (const R4 &a, const R4 &b) |
| R4 | logical_and (const R4 &a, const R4 &b) |
| R4 | logical_or (const R4 &a, const R4 &b) |
| R4 | logical_xor (const R4 &a, const R4 &b) |
| R4 | eq (const R4 &a, const R4 &b) |
| R4 | ne (const R4 &a, const R4 &b) |
| R4 | operator! (const R4 &a) |
| R4 | logical_not (const R4 &a) |
| SFFR4 | operator> (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | operator< (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | operator>= (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | operator<= (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | operator&& (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | operator|| (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | operator== (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | operator!= (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | gt (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | lt (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | ge (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | le (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | logical_and (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | logical_or (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | logical_xor (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | eq (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | ne (const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | operator! (const SFFR4 &a) |
| SFFR4 | logical_not (const SFFR4 &a) |
| WFFR4 | operator> (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | operator< (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | operator>= (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | operator<= (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | operator&& (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | operator|| (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | operator== (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | operator!= (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | gt (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | lt (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | ge (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | le (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | logical_and (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | logical_or (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | logical_xor (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | eq (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | ne (const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | operator! (const WFFR4 &a) |
| WFFR4 | logical_not (const WFFR4 &a) |
| SSR4 | operator> (const SSR4 &a, const SSR4 &b) |
| SSR4 | operator< (const SSR4 &a, const SSR4 &b) |
| SSR4 | operator>= (const SSR4 &a, const SSR4 &b) |
| SSR4 | operator<= (const SSR4 &a, const SSR4 &b) |
| SSR4 | operator&& (const SSR4 &a, const SSR4 &b) |
| SSR4 | operator|| (const SSR4 &a, const SSR4 &b) |
| SSR4 | operator== (const SSR4 &a, const SSR4 &b) |
| SSR4 | operator!= (const SSR4 &a, const SSR4 &b) |
| SSR4 | gt (const SSR4 &a, const SSR4 &b) |
| SSR4 | lt (const SSR4 &a, const SSR4 &b) |
| SSR4 | ge (const SSR4 &a, const SSR4 &b) |
| SSR4 | le (const SSR4 &a, const SSR4 &b) |
| SSR4 | logical_and (const SSR4 &a, const SSR4 &b) |
| SSR4 | logical_or (const SSR4 &a, const SSR4 &b) |
| SSR4 | logical_xor (const SSR4 &a, const SSR4 &b) |
| SSR4 | eq (const SSR4 &a, const SSR4 &b) |
| SSR4 | ne (const SSR4 &a, const SSR4 &b) |
| SSR4 | operator! (const SSR4 &a) |
| SSR4 | logical_not (const SSR4 &a) |
| SWR4 | operator> (const SWR4 &a, const SWR4 &b) |
| SWR4 | operator< (const SWR4 &a, const SWR4 &b) |
| SWR4 | operator>= (const SWR4 &a, const SWR4 &b) |
| SWR4 | operator<= (const SWR4 &a, const SWR4 &b) |
| SWR4 | operator&& (const SWR4 &a, const SWR4 &b) |
| SWR4 | operator|| (const SWR4 &a, const SWR4 &b) |
| SWR4 | operator== (const SWR4 &a, const SWR4 &b) |
| SWR4 | operator!= (const SWR4 &a, const SWR4 &b) |
| SWR4 | gt (const SWR4 &a, const SWR4 &b) |
| SWR4 | lt (const SWR4 &a, const SWR4 &b) |
| SWR4 | ge (const SWR4 &a, const SWR4 &b) |
| SWR4 | le (const SWR4 &a, const SWR4 &b) |
| SWR4 | logical_and (const SWR4 &a, const SWR4 &b) |
| SWR4 | logical_or (const SWR4 &a, const SWR4 &b) |
| SWR4 | logical_xor (const SWR4 &a, const SWR4 &b) |
| SWR4 | eq (const SWR4 &a, const SWR4 &b) |
| SWR4 | ne (const SWR4 &a, const SWR4 &b) |
| SWR4 | operator! (const SWR4 &a) |
| SWR4 | logical_not (const SWR4 &a) |
| WSR4 | operator> (const WSR4 &a, const WSR4 &b) |
| WSR4 | operator< (const WSR4 &a, const WSR4 &b) |
| WSR4 | operator>= (const WSR4 &a, const WSR4 &b) |
| WSR4 | operator<= (const WSR4 &a, const WSR4 &b) |
| WSR4 | operator&& (const WSR4 &a, const WSR4 &b) |
| WSR4 | operator|| (const WSR4 &a, const WSR4 &b) |
| WSR4 | operator== (const WSR4 &a, const WSR4 &b) |
| WSR4 | operator!= (const WSR4 &a, const WSR4 &b) |
| WSR4 | gt (const WSR4 &a, const WSR4 &b) |
| WSR4 | lt (const WSR4 &a, const WSR4 &b) |
| WSR4 | ge (const WSR4 &a, const WSR4 &b) |
| WSR4 | le (const WSR4 &a, const WSR4 &b) |
| WSR4 | logical_and (const WSR4 &a, const WSR4 &b) |
| WSR4 | logical_or (const WSR4 &a, const WSR4 &b) |
| WSR4 | logical_xor (const WSR4 &a, const WSR4 &b) |
| WSR4 | eq (const WSR4 &a, const WSR4 &b) |
| WSR4 | ne (const WSR4 &a, const WSR4 &b) |
| WSR4 | operator! (const WSR4 &a) |
| WSR4 | logical_not (const WSR4 &a) |
| WWR4 | operator> (const WWR4 &a, const WWR4 &b) |
| WWR4 | operator< (const WWR4 &a, const WWR4 &b) |
| WWR4 | operator>= (const WWR4 &a, const WWR4 &b) |
| WWR4 | operator<= (const WWR4 &a, const WWR4 &b) |
| WWR4 | operator&& (const WWR4 &a, const WWR4 &b) |
| WWR4 | operator|| (const WWR4 &a, const WWR4 &b) |
| WWR4 | operator== (const WWR4 &a, const WWR4 &b) |
| WWR4 | operator!= (const WWR4 &a, const WWR4 &b) |
| WWR4 | gt (const WWR4 &a, const WWR4 &b) |
| WWR4 | lt (const WWR4 &a, const WWR4 &b) |
| WWR4 | ge (const WWR4 &a, const WWR4 &b) |
| WWR4 | le (const WWR4 &a, const WWR4 &b) |
| WWR4 | logical_and (const WWR4 &a, const WWR4 &b) |
| WWR4 | logical_or (const WWR4 &a, const WWR4 &b) |
| WWR4 | logical_xor (const WWR4 &a, const WWR4 &b) |
| WWR4 | eq (const WWR4 &a, const WWR4 &b) |
| WWR4 | ne (const WWR4 &a, const WWR4 &b) |
| WWR4 | operator! (const WWR4 &a) |
| WWR4 | logical_not (const WWR4 &a) |
| Quaternion | operator> (const Quaternion &a, const Quaternion &b) |
| Quaternion | operator< (const Quaternion &a, const Quaternion &b) |
| Quaternion | operator>= (const Quaternion &a, const Quaternion &b) |
| Quaternion | operator<= (const Quaternion &a, const Quaternion &b) |
| Quaternion | operator&& (const Quaternion &a, const Quaternion &b) |
| Quaternion | operator|| (const Quaternion &a, const Quaternion &b) |
| Quaternion | operator== (const Quaternion &a, const Quaternion &b) |
| Quaternion | operator!= (const Quaternion &a, const Quaternion &b) |
| Quaternion | gt (const Quaternion &a, const Quaternion &b) |
| Quaternion | lt (const Quaternion &a, const Quaternion &b) |
| Quaternion | ge (const Quaternion &a, const Quaternion &b) |
| Quaternion | le (const Quaternion &a, const Quaternion &b) |
| Quaternion | logical_and (const Quaternion &a, const Quaternion &b) |
| Quaternion | logical_or (const Quaternion &a, const Quaternion &b) |
| Quaternion | logical_xor (const Quaternion &a, const Quaternion &b) |
| Quaternion | eq (const Quaternion &a, const Quaternion &b) |
| Quaternion | ne (const Quaternion &a, const Quaternion &b) |
| Quaternion | operator! (const Quaternion &a) |
| Quaternion | logical_not (const Quaternion &a) |
| MillerIndex | operator> (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | operator< (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | operator>= (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | operator<= (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | operator&& (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | operator|| (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | operator== (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | operator!= (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | gt (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | lt (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | ge (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | le (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | logical_and (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | logical_or (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | logical_xor (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | eq (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | ne (const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | operator! (const MillerIndex &a) |
| MillerIndex | logical_not (const MillerIndex &a) |
| Vec | operator> (const Vec &a, const Scalar &b) |
| Vec | operator> (const Scalar &a, const Vec &b) |
| Vec | operator< (const Vec &a, const Scalar &b) |
| Vec | operator< (const Scalar &a, const Vec &b) |
| Vec | operator>= (const Vec &a, const Scalar &b) |
| Vec | operator>= (const Scalar &a, const Vec &b) |
| Vec | operator<= (const Vec &a, const Scalar &b) |
| Vec | operator<= (const Scalar &a, const Vec &b) |
| Vec | operator&& (const Vec &a, const Scalar &b) |
| Vec | operator&& (const Scalar &a, const Vec &b) |
| Vec | operator|| (const Vec &a, const Scalar &b) |
| Vec | operator|| (const Scalar &a, const Vec &b) |
| Vec | operator== (const Vec &a, const Scalar &b) |
| Vec | operator== (const Scalar &a, const Vec &b) |
| Vec | operator!= (const Vec &a, const Scalar &b) |
| Vec | operator!= (const Scalar &a, const Vec &b) |
| Vec | gt (const Vec &a, const Scalar &b) |
| Vec | gt (const Scalar &a, const Vec &b) |
| Vec | lt (const Vec &a, const Scalar &b) |
| Vec | lt (const Scalar &a, const Vec &b) |
| Vec | ge (const Vec &a, const Scalar &b) |
| Vec | ge (const Scalar &a, const Vec &b) |
| Vec | le (const Vec &a, const Scalar &b) |
| Vec | le (const Scalar &a, const Vec &b) |
| Vec | logical_and (const Vec &a, const Scalar &b) |
| Vec | logical_and (const Scalar &a, const Vec &b) |
| Vec | logical_or (const Vec &a, const Scalar &b) |
| Vec | logical_or (const Scalar &a, const Vec &b) |
| Vec | logical_xor (const Vec &a, const Scalar &b) |
| Vec | logical_xor (const Scalar &a, const Vec &b) |
| Vec | eq (const Vec &a, const Scalar &b) |
| Vec | eq (const Scalar &a, const Vec &b) |
| Vec | ne (const Vec &a, const Scalar &b) |
| Vec | ne (const Scalar &a, const Vec &b) |
| Rot | operator> (const Rot &a, const Scalar &b) |
| Rot | operator> (const Scalar &a, const Rot &b) |
| Rot | operator< (const Rot &a, const Scalar &b) |
| Rot | operator< (const Scalar &a, const Rot &b) |
| Rot | operator>= (const Rot &a, const Scalar &b) |
| Rot | operator>= (const Scalar &a, const Rot &b) |
| Rot | operator<= (const Rot &a, const Scalar &b) |
| Rot | operator<= (const Scalar &a, const Rot &b) |
| Rot | operator&& (const Rot &a, const Scalar &b) |
| Rot | operator&& (const Scalar &a, const Rot &b) |
| Rot | operator|| (const Rot &a, const Scalar &b) |
| Rot | operator|| (const Scalar &a, const Rot &b) |
| Rot | operator== (const Rot &a, const Scalar &b) |
| Rot | operator== (const Scalar &a, const Rot &b) |
| Rot | operator!= (const Rot &a, const Scalar &b) |
| Rot | operator!= (const Scalar &a, const Rot &b) |
| Rot | gt (const Rot &a, const Scalar &b) |
| Rot | gt (const Scalar &a, const Rot &b) |
| Rot | lt (const Rot &a, const Scalar &b) |
| Rot | lt (const Scalar &a, const Rot &b) |
| Rot | ge (const Rot &a, const Scalar &b) |
| Rot | ge (const Scalar &a, const Rot &b) |
| Rot | le (const Rot &a, const Scalar &b) |
| Rot | le (const Scalar &a, const Rot &b) |
| Rot | logical_and (const Rot &a, const Scalar &b) |
| Rot | logical_and (const Scalar &a, const Rot &b) |
| Rot | logical_or (const Rot &a, const Scalar &b) |
| Rot | logical_or (const Scalar &a, const Rot &b) |
| Rot | logical_xor (const Rot &a, const Scalar &b) |
| Rot | logical_xor (const Scalar &a, const Rot &b) |
| Rot | eq (const Rot &a, const Scalar &b) |
| Rot | eq (const Scalar &a, const Rot &b) |
| Rot | ne (const Rot &a, const Scalar &b) |
| Rot | ne (const Scalar &a, const Rot &b) |
| WR2 | operator> (const WR2 &a, const Scalar &b) |
| WR2 | operator> (const Scalar &a, const WR2 &b) |
| WR2 | operator< (const WR2 &a, const Scalar &b) |
| WR2 | operator< (const Scalar &a, const WR2 &b) |
| WR2 | operator>= (const WR2 &a, const Scalar &b) |
| WR2 | operator>= (const Scalar &a, const WR2 &b) |
| WR2 | operator<= (const WR2 &a, const Scalar &b) |
| WR2 | operator<= (const Scalar &a, const WR2 &b) |
| WR2 | operator&& (const WR2 &a, const Scalar &b) |
| WR2 | operator&& (const Scalar &a, const WR2 &b) |
| WR2 | operator|| (const WR2 &a, const Scalar &b) |
| WR2 | operator|| (const Scalar &a, const WR2 &b) |
| WR2 | operator== (const WR2 &a, const Scalar &b) |
| WR2 | operator== (const Scalar &a, const WR2 &b) |
| WR2 | operator!= (const WR2 &a, const Scalar &b) |
| WR2 | operator!= (const Scalar &a, const WR2 &b) |
| WR2 | gt (const WR2 &a, const Scalar &b) |
| WR2 | gt (const Scalar &a, const WR2 &b) |
| WR2 | lt (const WR2 &a, const Scalar &b) |
| WR2 | lt (const Scalar &a, const WR2 &b) |
| WR2 | ge (const WR2 &a, const Scalar &b) |
| WR2 | ge (const Scalar &a, const WR2 &b) |
| WR2 | le (const WR2 &a, const Scalar &b) |
| WR2 | le (const Scalar &a, const WR2 &b) |
| WR2 | logical_and (const WR2 &a, const Scalar &b) |
| WR2 | logical_and (const Scalar &a, const WR2 &b) |
| WR2 | logical_or (const WR2 &a, const Scalar &b) |
| WR2 | logical_or (const Scalar &a, const WR2 &b) |
| WR2 | logical_xor (const WR2 &a, const Scalar &b) |
| WR2 | logical_xor (const Scalar &a, const WR2 &b) |
| WR2 | eq (const WR2 &a, const Scalar &b) |
| WR2 | eq (const Scalar &a, const WR2 &b) |
| WR2 | ne (const WR2 &a, const Scalar &b) |
| WR2 | ne (const Scalar &a, const WR2 &b) |
| R2 | operator> (const R2 &a, const Scalar &b) |
| R2 | operator> (const Scalar &a, const R2 &b) |
| R2 | operator< (const R2 &a, const Scalar &b) |
| R2 | operator< (const Scalar &a, const R2 &b) |
| R2 | operator>= (const R2 &a, const Scalar &b) |
| R2 | operator>= (const Scalar &a, const R2 &b) |
| R2 | operator<= (const R2 &a, const Scalar &b) |
| R2 | operator<= (const Scalar &a, const R2 &b) |
| R2 | operator&& (const R2 &a, const Scalar &b) |
| R2 | operator&& (const Scalar &a, const R2 &b) |
| R2 | operator|| (const R2 &a, const Scalar &b) |
| R2 | operator|| (const Scalar &a, const R2 &b) |
| R2 | operator== (const R2 &a, const Scalar &b) |
| R2 | operator== (const Scalar &a, const R2 &b) |
| R2 | operator!= (const R2 &a, const Scalar &b) |
| R2 | operator!= (const Scalar &a, const R2 &b) |
| R2 | gt (const R2 &a, const Scalar &b) |
| R2 | gt (const Scalar &a, const R2 &b) |
| R2 | lt (const R2 &a, const Scalar &b) |
| R2 | lt (const Scalar &a, const R2 &b) |
| R2 | ge (const R2 &a, const Scalar &b) |
| R2 | ge (const Scalar &a, const R2 &b) |
| R2 | le (const R2 &a, const Scalar &b) |
| R2 | le (const Scalar &a, const R2 &b) |
| R2 | logical_and (const R2 &a, const Scalar &b) |
| R2 | logical_and (const Scalar &a, const R2 &b) |
| R2 | logical_or (const R2 &a, const Scalar &b) |
| R2 | logical_or (const Scalar &a, const R2 &b) |
| R2 | logical_xor (const R2 &a, const Scalar &b) |
| R2 | logical_xor (const Scalar &a, const R2 &b) |
| R2 | eq (const R2 &a, const Scalar &b) |
| R2 | eq (const Scalar &a, const R2 &b) |
| R2 | ne (const R2 &a, const Scalar &b) |
| R2 | ne (const Scalar &a, const R2 &b) |
| SR2 | operator> (const SR2 &a, const Scalar &b) |
| SR2 | operator> (const Scalar &a, const SR2 &b) |
| SR2 | operator< (const SR2 &a, const Scalar &b) |
| SR2 | operator< (const Scalar &a, const SR2 &b) |
| SR2 | operator>= (const SR2 &a, const Scalar &b) |
| SR2 | operator>= (const Scalar &a, const SR2 &b) |
| SR2 | operator<= (const SR2 &a, const Scalar &b) |
| SR2 | operator<= (const Scalar &a, const SR2 &b) |
| SR2 | operator&& (const SR2 &a, const Scalar &b) |
| SR2 | operator&& (const Scalar &a, const SR2 &b) |
| SR2 | operator|| (const SR2 &a, const Scalar &b) |
| SR2 | operator|| (const Scalar &a, const SR2 &b) |
| SR2 | operator== (const SR2 &a, const Scalar &b) |
| SR2 | operator== (const Scalar &a, const SR2 &b) |
| SR2 | operator!= (const SR2 &a, const Scalar &b) |
| SR2 | operator!= (const Scalar &a, const SR2 &b) |
| SR2 | gt (const SR2 &a, const Scalar &b) |
| SR2 | gt (const Scalar &a, const SR2 &b) |
| SR2 | lt (const SR2 &a, const Scalar &b) |
| SR2 | lt (const Scalar &a, const SR2 &b) |
| SR2 | ge (const SR2 &a, const Scalar &b) |
| SR2 | ge (const Scalar &a, const SR2 &b) |
| SR2 | le (const SR2 &a, const Scalar &b) |
| SR2 | le (const Scalar &a, const SR2 &b) |
| SR2 | logical_and (const SR2 &a, const Scalar &b) |
| SR2 | logical_and (const Scalar &a, const SR2 &b) |
| SR2 | logical_or (const SR2 &a, const Scalar &b) |
| SR2 | logical_or (const Scalar &a, const SR2 &b) |
| SR2 | logical_xor (const SR2 &a, const Scalar &b) |
| SR2 | logical_xor (const Scalar &a, const SR2 &b) |
| SR2 | eq (const SR2 &a, const Scalar &b) |
| SR2 | eq (const Scalar &a, const SR2 &b) |
| SR2 | ne (const SR2 &a, const Scalar &b) |
| SR2 | ne (const Scalar &a, const SR2 &b) |
| R3 | operator> (const R3 &a, const Scalar &b) |
| R3 | operator> (const Scalar &a, const R3 &b) |
| R3 | operator< (const R3 &a, const Scalar &b) |
| R3 | operator< (const Scalar &a, const R3 &b) |
| R3 | operator>= (const R3 &a, const Scalar &b) |
| R3 | operator>= (const Scalar &a, const R3 &b) |
| R3 | operator<= (const R3 &a, const Scalar &b) |
| R3 | operator<= (const Scalar &a, const R3 &b) |
| R3 | operator&& (const R3 &a, const Scalar &b) |
| R3 | operator&& (const Scalar &a, const R3 &b) |
| R3 | operator|| (const R3 &a, const Scalar &b) |
| R3 | operator|| (const Scalar &a, const R3 &b) |
| R3 | operator== (const R3 &a, const Scalar &b) |
| R3 | operator== (const Scalar &a, const R3 &b) |
| R3 | operator!= (const R3 &a, const Scalar &b) |
| R3 | operator!= (const Scalar &a, const R3 &b) |
| R3 | gt (const R3 &a, const Scalar &b) |
| R3 | gt (const Scalar &a, const R3 &b) |
| R3 | lt (const R3 &a, const Scalar &b) |
| R3 | lt (const Scalar &a, const R3 &b) |
| R3 | ge (const R3 &a, const Scalar &b) |
| R3 | ge (const Scalar &a, const R3 &b) |
| R3 | le (const R3 &a, const Scalar &b) |
| R3 | le (const Scalar &a, const R3 &b) |
| R3 | logical_and (const R3 &a, const Scalar &b) |
| R3 | logical_and (const Scalar &a, const R3 &b) |
| R3 | logical_or (const R3 &a, const Scalar &b) |
| R3 | logical_or (const Scalar &a, const R3 &b) |
| R3 | logical_xor (const R3 &a, const Scalar &b) |
| R3 | logical_xor (const Scalar &a, const R3 &b) |
| R3 | eq (const R3 &a, const Scalar &b) |
| R3 | eq (const Scalar &a, const R3 &b) |
| R3 | ne (const R3 &a, const Scalar &b) |
| R3 | ne (const Scalar &a, const R3 &b) |
| SFR3 | operator> (const SFR3 &a, const Scalar &b) |
| SFR3 | operator> (const Scalar &a, const SFR3 &b) |
| SFR3 | operator< (const SFR3 &a, const Scalar &b) |
| SFR3 | operator< (const Scalar &a, const SFR3 &b) |
| SFR3 | operator>= (const SFR3 &a, const Scalar &b) |
| SFR3 | operator>= (const Scalar &a, const SFR3 &b) |
| SFR3 | operator<= (const SFR3 &a, const Scalar &b) |
| SFR3 | operator<= (const Scalar &a, const SFR3 &b) |
| SFR3 | operator&& (const SFR3 &a, const Scalar &b) |
| SFR3 | operator&& (const Scalar &a, const SFR3 &b) |
| SFR3 | operator|| (const SFR3 &a, const Scalar &b) |
| SFR3 | operator|| (const Scalar &a, const SFR3 &b) |
| SFR3 | operator== (const SFR3 &a, const Scalar &b) |
| SFR3 | operator== (const Scalar &a, const SFR3 &b) |
| SFR3 | operator!= (const SFR3 &a, const Scalar &b) |
| SFR3 | operator!= (const Scalar &a, const SFR3 &b) |
| SFR3 | gt (const SFR3 &a, const Scalar &b) |
| SFR3 | gt (const Scalar &a, const SFR3 &b) |
| SFR3 | lt (const SFR3 &a, const Scalar &b) |
| SFR3 | lt (const Scalar &a, const SFR3 &b) |
| SFR3 | ge (const SFR3 &a, const Scalar &b) |
| SFR3 | ge (const Scalar &a, const SFR3 &b) |
| SFR3 | le (const SFR3 &a, const Scalar &b) |
| SFR3 | le (const Scalar &a, const SFR3 &b) |
| SFR3 | logical_and (const SFR3 &a, const Scalar &b) |
| SFR3 | logical_and (const Scalar &a, const SFR3 &b) |
| SFR3 | logical_or (const SFR3 &a, const Scalar &b) |
| SFR3 | logical_or (const Scalar &a, const SFR3 &b) |
| SFR3 | logical_xor (const SFR3 &a, const Scalar &b) |
| SFR3 | logical_xor (const Scalar &a, const SFR3 &b) |
| SFR3 | eq (const SFR3 &a, const Scalar &b) |
| SFR3 | eq (const Scalar &a, const SFR3 &b) |
| SFR3 | ne (const SFR3 &a, const Scalar &b) |
| SFR3 | ne (const Scalar &a, const SFR3 &b) |
| R4 | operator> (const R4 &a, const Scalar &b) |
| R4 | operator> (const Scalar &a, const R4 &b) |
| R4 | operator< (const R4 &a, const Scalar &b) |
| R4 | operator< (const Scalar &a, const R4 &b) |
| R4 | operator>= (const R4 &a, const Scalar &b) |
| R4 | operator>= (const Scalar &a, const R4 &b) |
| R4 | operator<= (const R4 &a, const Scalar &b) |
| R4 | operator<= (const Scalar &a, const R4 &b) |
| R4 | operator&& (const R4 &a, const Scalar &b) |
| R4 | operator&& (const Scalar &a, const R4 &b) |
| R4 | operator|| (const R4 &a, const Scalar &b) |
| R4 | operator|| (const Scalar &a, const R4 &b) |
| R4 | operator== (const R4 &a, const Scalar &b) |
| R4 | operator== (const Scalar &a, const R4 &b) |
| R4 | operator!= (const R4 &a, const Scalar &b) |
| R4 | operator!= (const Scalar &a, const R4 &b) |
| R4 | gt (const R4 &a, const Scalar &b) |
| R4 | gt (const Scalar &a, const R4 &b) |
| R4 | lt (const R4 &a, const Scalar &b) |
| R4 | lt (const Scalar &a, const R4 &b) |
| R4 | ge (const R4 &a, const Scalar &b) |
| R4 | ge (const Scalar &a, const R4 &b) |
| R4 | le (const R4 &a, const Scalar &b) |
| R4 | le (const Scalar &a, const R4 &b) |
| R4 | logical_and (const R4 &a, const Scalar &b) |
| R4 | logical_and (const Scalar &a, const R4 &b) |
| R4 | logical_or (const R4 &a, const Scalar &b) |
| R4 | logical_or (const Scalar &a, const R4 &b) |
| R4 | logical_xor (const R4 &a, const Scalar &b) |
| R4 | logical_xor (const Scalar &a, const R4 &b) |
| R4 | eq (const R4 &a, const Scalar &b) |
| R4 | eq (const Scalar &a, const R4 &b) |
| R4 | ne (const R4 &a, const Scalar &b) |
| R4 | ne (const Scalar &a, const R4 &b) |
| SFFR4 | operator> (const SFFR4 &a, const Scalar &b) |
| SFFR4 | operator> (const Scalar &a, const SFFR4 &b) |
| SFFR4 | operator< (const SFFR4 &a, const Scalar &b) |
| SFFR4 | operator< (const Scalar &a, const SFFR4 &b) |
| SFFR4 | operator>= (const SFFR4 &a, const Scalar &b) |
| SFFR4 | operator>= (const Scalar &a, const SFFR4 &b) |
| SFFR4 | operator<= (const SFFR4 &a, const Scalar &b) |
| SFFR4 | operator<= (const Scalar &a, const SFFR4 &b) |
| SFFR4 | operator&& (const SFFR4 &a, const Scalar &b) |
| SFFR4 | operator&& (const Scalar &a, const SFFR4 &b) |
| SFFR4 | operator|| (const SFFR4 &a, const Scalar &b) |
| SFFR4 | operator|| (const Scalar &a, const SFFR4 &b) |
| SFFR4 | operator== (const SFFR4 &a, const Scalar &b) |
| SFFR4 | operator== (const Scalar &a, const SFFR4 &b) |
| SFFR4 | operator!= (const SFFR4 &a, const Scalar &b) |
| SFFR4 | operator!= (const Scalar &a, const SFFR4 &b) |
| SFFR4 | gt (const SFFR4 &a, const Scalar &b) |
| SFFR4 | gt (const Scalar &a, const SFFR4 &b) |
| SFFR4 | lt (const SFFR4 &a, const Scalar &b) |
| SFFR4 | lt (const Scalar &a, const SFFR4 &b) |
| SFFR4 | ge (const SFFR4 &a, const Scalar &b) |
| SFFR4 | ge (const Scalar &a, const SFFR4 &b) |
| SFFR4 | le (const SFFR4 &a, const Scalar &b) |
| SFFR4 | le (const Scalar &a, const SFFR4 &b) |
| SFFR4 | logical_and (const SFFR4 &a, const Scalar &b) |
| SFFR4 | logical_and (const Scalar &a, const SFFR4 &b) |
| SFFR4 | logical_or (const SFFR4 &a, const Scalar &b) |
| SFFR4 | logical_or (const Scalar &a, const SFFR4 &b) |
| SFFR4 | logical_xor (const SFFR4 &a, const Scalar &b) |
| SFFR4 | logical_xor (const Scalar &a, const SFFR4 &b) |
| SFFR4 | eq (const SFFR4 &a, const Scalar &b) |
| SFFR4 | eq (const Scalar &a, const SFFR4 &b) |
| SFFR4 | ne (const SFFR4 &a, const Scalar &b) |
| SFFR4 | ne (const Scalar &a, const SFFR4 &b) |
| WFFR4 | operator> (const WFFR4 &a, const Scalar &b) |
| WFFR4 | operator> (const Scalar &a, const WFFR4 &b) |
| WFFR4 | operator< (const WFFR4 &a, const Scalar &b) |
| WFFR4 | operator< (const Scalar &a, const WFFR4 &b) |
| WFFR4 | operator>= (const WFFR4 &a, const Scalar &b) |
| WFFR4 | operator>= (const Scalar &a, const WFFR4 &b) |
| WFFR4 | operator<= (const WFFR4 &a, const Scalar &b) |
| WFFR4 | operator<= (const Scalar &a, const WFFR4 &b) |
| WFFR4 | operator&& (const WFFR4 &a, const Scalar &b) |
| WFFR4 | operator&& (const Scalar &a, const WFFR4 &b) |
| WFFR4 | operator|| (const WFFR4 &a, const Scalar &b) |
| WFFR4 | operator|| (const Scalar &a, const WFFR4 &b) |
| WFFR4 | operator== (const WFFR4 &a, const Scalar &b) |
| WFFR4 | operator== (const Scalar &a, const WFFR4 &b) |
| WFFR4 | operator!= (const WFFR4 &a, const Scalar &b) |
| WFFR4 | operator!= (const Scalar &a, const WFFR4 &b) |
| WFFR4 | gt (const WFFR4 &a, const Scalar &b) |
| WFFR4 | gt (const Scalar &a, const WFFR4 &b) |
| WFFR4 | lt (const WFFR4 &a, const Scalar &b) |
| WFFR4 | lt (const Scalar &a, const WFFR4 &b) |
| WFFR4 | ge (const WFFR4 &a, const Scalar &b) |
| WFFR4 | ge (const Scalar &a, const WFFR4 &b) |
| WFFR4 | le (const WFFR4 &a, const Scalar &b) |
| WFFR4 | le (const Scalar &a, const WFFR4 &b) |
| WFFR4 | logical_and (const WFFR4 &a, const Scalar &b) |
| WFFR4 | logical_and (const Scalar &a, const WFFR4 &b) |
| WFFR4 | logical_or (const WFFR4 &a, const Scalar &b) |
| WFFR4 | logical_or (const Scalar &a, const WFFR4 &b) |
| WFFR4 | logical_xor (const WFFR4 &a, const Scalar &b) |
| WFFR4 | logical_xor (const Scalar &a, const WFFR4 &b) |
| WFFR4 | eq (const WFFR4 &a, const Scalar &b) |
| WFFR4 | eq (const Scalar &a, const WFFR4 &b) |
| WFFR4 | ne (const WFFR4 &a, const Scalar &b) |
| WFFR4 | ne (const Scalar &a, const WFFR4 &b) |
| SSR4 | operator> (const SSR4 &a, const Scalar &b) |
| SSR4 | operator> (const Scalar &a, const SSR4 &b) |
| SSR4 | operator< (const SSR4 &a, const Scalar &b) |
| SSR4 | operator< (const Scalar &a, const SSR4 &b) |
| SSR4 | operator>= (const SSR4 &a, const Scalar &b) |
| SSR4 | operator>= (const Scalar &a, const SSR4 &b) |
| SSR4 | operator<= (const SSR4 &a, const Scalar &b) |
| SSR4 | operator<= (const Scalar &a, const SSR4 &b) |
| SSR4 | operator&& (const SSR4 &a, const Scalar &b) |
| SSR4 | operator&& (const Scalar &a, const SSR4 &b) |
| SSR4 | operator|| (const SSR4 &a, const Scalar &b) |
| SSR4 | operator|| (const Scalar &a, const SSR4 &b) |
| SSR4 | operator== (const SSR4 &a, const Scalar &b) |
| SSR4 | operator== (const Scalar &a, const SSR4 &b) |
| SSR4 | operator!= (const SSR4 &a, const Scalar &b) |
| SSR4 | operator!= (const Scalar &a, const SSR4 &b) |
| SSR4 | gt (const SSR4 &a, const Scalar &b) |
| SSR4 | gt (const Scalar &a, const SSR4 &b) |
| SSR4 | lt (const SSR4 &a, const Scalar &b) |
| SSR4 | lt (const Scalar &a, const SSR4 &b) |
| SSR4 | ge (const SSR4 &a, const Scalar &b) |
| SSR4 | ge (const Scalar &a, const SSR4 &b) |
| SSR4 | le (const SSR4 &a, const Scalar &b) |
| SSR4 | le (const Scalar &a, const SSR4 &b) |
| SSR4 | logical_and (const SSR4 &a, const Scalar &b) |
| SSR4 | logical_and (const Scalar &a, const SSR4 &b) |
| SSR4 | logical_or (const SSR4 &a, const Scalar &b) |
| SSR4 | logical_or (const Scalar &a, const SSR4 &b) |
| SSR4 | logical_xor (const SSR4 &a, const Scalar &b) |
| SSR4 | logical_xor (const Scalar &a, const SSR4 &b) |
| SSR4 | eq (const SSR4 &a, const Scalar &b) |
| SSR4 | eq (const Scalar &a, const SSR4 &b) |
| SSR4 | ne (const SSR4 &a, const Scalar &b) |
| SSR4 | ne (const Scalar &a, const SSR4 &b) |
| SWR4 | operator> (const SWR4 &a, const Scalar &b) |
| SWR4 | operator> (const Scalar &a, const SWR4 &b) |
| SWR4 | operator< (const SWR4 &a, const Scalar &b) |
| SWR4 | operator< (const Scalar &a, const SWR4 &b) |
| SWR4 | operator>= (const SWR4 &a, const Scalar &b) |
| SWR4 | operator>= (const Scalar &a, const SWR4 &b) |
| SWR4 | operator<= (const SWR4 &a, const Scalar &b) |
| SWR4 | operator<= (const Scalar &a, const SWR4 &b) |
| SWR4 | operator&& (const SWR4 &a, const Scalar &b) |
| SWR4 | operator&& (const Scalar &a, const SWR4 &b) |
| SWR4 | operator|| (const SWR4 &a, const Scalar &b) |
| SWR4 | operator|| (const Scalar &a, const SWR4 &b) |
| SWR4 | operator== (const SWR4 &a, const Scalar &b) |
| SWR4 | operator== (const Scalar &a, const SWR4 &b) |
| SWR4 | operator!= (const SWR4 &a, const Scalar &b) |
| SWR4 | operator!= (const Scalar &a, const SWR4 &b) |
| SWR4 | gt (const SWR4 &a, const Scalar &b) |
| SWR4 | gt (const Scalar &a, const SWR4 &b) |
| SWR4 | lt (const SWR4 &a, const Scalar &b) |
| SWR4 | lt (const Scalar &a, const SWR4 &b) |
| SWR4 | ge (const SWR4 &a, const Scalar &b) |
| SWR4 | ge (const Scalar &a, const SWR4 &b) |
| SWR4 | le (const SWR4 &a, const Scalar &b) |
| SWR4 | le (const Scalar &a, const SWR4 &b) |
| SWR4 | logical_and (const SWR4 &a, const Scalar &b) |
| SWR4 | logical_and (const Scalar &a, const SWR4 &b) |
| SWR4 | logical_or (const SWR4 &a, const Scalar &b) |
| SWR4 | logical_or (const Scalar &a, const SWR4 &b) |
| SWR4 | logical_xor (const SWR4 &a, const Scalar &b) |
| SWR4 | logical_xor (const Scalar &a, const SWR4 &b) |
| SWR4 | eq (const SWR4 &a, const Scalar &b) |
| SWR4 | eq (const Scalar &a, const SWR4 &b) |
| SWR4 | ne (const SWR4 &a, const Scalar &b) |
| SWR4 | ne (const Scalar &a, const SWR4 &b) |
| WSR4 | operator> (const WSR4 &a, const Scalar &b) |
| WSR4 | operator> (const Scalar &a, const WSR4 &b) |
| WSR4 | operator< (const WSR4 &a, const Scalar &b) |
| WSR4 | operator< (const Scalar &a, const WSR4 &b) |
| WSR4 | operator>= (const WSR4 &a, const Scalar &b) |
| WSR4 | operator>= (const Scalar &a, const WSR4 &b) |
| WSR4 | operator<= (const WSR4 &a, const Scalar &b) |
| WSR4 | operator<= (const Scalar &a, const WSR4 &b) |
| WSR4 | operator&& (const WSR4 &a, const Scalar &b) |
| WSR4 | operator&& (const Scalar &a, const WSR4 &b) |
| WSR4 | operator|| (const WSR4 &a, const Scalar &b) |
| WSR4 | operator|| (const Scalar &a, const WSR4 &b) |
| WSR4 | operator== (const WSR4 &a, const Scalar &b) |
| WSR4 | operator== (const Scalar &a, const WSR4 &b) |
| WSR4 | operator!= (const WSR4 &a, const Scalar &b) |
| WSR4 | operator!= (const Scalar &a, const WSR4 &b) |
| WSR4 | gt (const WSR4 &a, const Scalar &b) |
| WSR4 | gt (const Scalar &a, const WSR4 &b) |
| WSR4 | lt (const WSR4 &a, const Scalar &b) |
| WSR4 | lt (const Scalar &a, const WSR4 &b) |
| WSR4 | ge (const WSR4 &a, const Scalar &b) |
| WSR4 | ge (const Scalar &a, const WSR4 &b) |
| WSR4 | le (const WSR4 &a, const Scalar &b) |
| WSR4 | le (const Scalar &a, const WSR4 &b) |
| WSR4 | logical_and (const WSR4 &a, const Scalar &b) |
| WSR4 | logical_and (const Scalar &a, const WSR4 &b) |
| WSR4 | logical_or (const WSR4 &a, const Scalar &b) |
| WSR4 | logical_or (const Scalar &a, const WSR4 &b) |
| WSR4 | logical_xor (const WSR4 &a, const Scalar &b) |
| WSR4 | logical_xor (const Scalar &a, const WSR4 &b) |
| WSR4 | eq (const WSR4 &a, const Scalar &b) |
| WSR4 | eq (const Scalar &a, const WSR4 &b) |
| WSR4 | ne (const WSR4 &a, const Scalar &b) |
| WSR4 | ne (const Scalar &a, const WSR4 &b) |
| WWR4 | operator> (const WWR4 &a, const Scalar &b) |
| WWR4 | operator> (const Scalar &a, const WWR4 &b) |
| WWR4 | operator< (const WWR4 &a, const Scalar &b) |
| WWR4 | operator< (const Scalar &a, const WWR4 &b) |
| WWR4 | operator>= (const WWR4 &a, const Scalar &b) |
| WWR4 | operator>= (const Scalar &a, const WWR4 &b) |
| WWR4 | operator<= (const WWR4 &a, const Scalar &b) |
| WWR4 | operator<= (const Scalar &a, const WWR4 &b) |
| WWR4 | operator&& (const WWR4 &a, const Scalar &b) |
| WWR4 | operator&& (const Scalar &a, const WWR4 &b) |
| WWR4 | operator|| (const WWR4 &a, const Scalar &b) |
| WWR4 | operator|| (const Scalar &a, const WWR4 &b) |
| WWR4 | operator== (const WWR4 &a, const Scalar &b) |
| WWR4 | operator== (const Scalar &a, const WWR4 &b) |
| WWR4 | operator!= (const WWR4 &a, const Scalar &b) |
| WWR4 | operator!= (const Scalar &a, const WWR4 &b) |
| WWR4 | gt (const WWR4 &a, const Scalar &b) |
| WWR4 | gt (const Scalar &a, const WWR4 &b) |
| WWR4 | lt (const WWR4 &a, const Scalar &b) |
| WWR4 | lt (const Scalar &a, const WWR4 &b) |
| WWR4 | ge (const WWR4 &a, const Scalar &b) |
| WWR4 | ge (const Scalar &a, const WWR4 &b) |
| WWR4 | le (const WWR4 &a, const Scalar &b) |
| WWR4 | le (const Scalar &a, const WWR4 &b) |
| WWR4 | logical_and (const WWR4 &a, const Scalar &b) |
| WWR4 | logical_and (const Scalar &a, const WWR4 &b) |
| WWR4 | logical_or (const WWR4 &a, const Scalar &b) |
| WWR4 | logical_or (const Scalar &a, const WWR4 &b) |
| WWR4 | logical_xor (const WWR4 &a, const Scalar &b) |
| WWR4 | logical_xor (const Scalar &a, const WWR4 &b) |
| WWR4 | eq (const WWR4 &a, const Scalar &b) |
| WWR4 | eq (const Scalar &a, const WWR4 &b) |
| WWR4 | ne (const WWR4 &a, const Scalar &b) |
| WWR4 | ne (const Scalar &a, const WWR4 &b) |
| Quaternion | operator> (const Quaternion &a, const Scalar &b) |
| Quaternion | operator> (const Scalar &a, const Quaternion &b) |
| Quaternion | operator< (const Quaternion &a, const Scalar &b) |
| Quaternion | operator< (const Scalar &a, const Quaternion &b) |
| Quaternion | operator>= (const Quaternion &a, const Scalar &b) |
| Quaternion | operator>= (const Scalar &a, const Quaternion &b) |
| Quaternion | operator<= (const Quaternion &a, const Scalar &b) |
| Quaternion | operator<= (const Scalar &a, const Quaternion &b) |
| Quaternion | operator&& (const Quaternion &a, const Scalar &b) |
| Quaternion | operator&& (const Scalar &a, const Quaternion &b) |
| Quaternion | operator|| (const Quaternion &a, const Scalar &b) |
| Quaternion | operator|| (const Scalar &a, const Quaternion &b) |
| Quaternion | operator== (const Quaternion &a, const Scalar &b) |
| Quaternion | operator== (const Scalar &a, const Quaternion &b) |
| Quaternion | operator!= (const Quaternion &a, const Scalar &b) |
| Quaternion | operator!= (const Scalar &a, const Quaternion &b) |
| Quaternion | gt (const Quaternion &a, const Scalar &b) |
| Quaternion | gt (const Scalar &a, const Quaternion &b) |
| Quaternion | lt (const Quaternion &a, const Scalar &b) |
| Quaternion | lt (const Scalar &a, const Quaternion &b) |
| Quaternion | ge (const Quaternion &a, const Scalar &b) |
| Quaternion | ge (const Scalar &a, const Quaternion &b) |
| Quaternion | le (const Quaternion &a, const Scalar &b) |
| Quaternion | le (const Scalar &a, const Quaternion &b) |
| Quaternion | logical_and (const Quaternion &a, const Scalar &b) |
| Quaternion | logical_and (const Scalar &a, const Quaternion &b) |
| Quaternion | logical_or (const Quaternion &a, const Scalar &b) |
| Quaternion | logical_or (const Scalar &a, const Quaternion &b) |
| Quaternion | logical_xor (const Quaternion &a, const Scalar &b) |
| Quaternion | logical_xor (const Scalar &a, const Quaternion &b) |
| Quaternion | eq (const Quaternion &a, const Scalar &b) |
| Quaternion | eq (const Scalar &a, const Quaternion &b) |
| Quaternion | ne (const Quaternion &a, const Scalar &b) |
| Quaternion | ne (const Scalar &a, const Quaternion &b) |
| MillerIndex | operator> (const MillerIndex &a, const Scalar &b) |
| MillerIndex | operator> (const Scalar &a, const MillerIndex &b) |
| MillerIndex | operator< (const MillerIndex &a, const Scalar &b) |
| MillerIndex | operator< (const Scalar &a, const MillerIndex &b) |
| MillerIndex | operator>= (const MillerIndex &a, const Scalar &b) |
| MillerIndex | operator>= (const Scalar &a, const MillerIndex &b) |
| MillerIndex | operator<= (const MillerIndex &a, const Scalar &b) |
| MillerIndex | operator<= (const Scalar &a, const MillerIndex &b) |
| MillerIndex | operator&& (const MillerIndex &a, const Scalar &b) |
| MillerIndex | operator&& (const Scalar &a, const MillerIndex &b) |
| MillerIndex | operator|| (const MillerIndex &a, const Scalar &b) |
| MillerIndex | operator|| (const Scalar &a, const MillerIndex &b) |
| MillerIndex | operator== (const MillerIndex &a, const Scalar &b) |
| MillerIndex | operator== (const Scalar &a, const MillerIndex &b) |
| MillerIndex | operator!= (const MillerIndex &a, const Scalar &b) |
| MillerIndex | operator!= (const Scalar &a, const MillerIndex &b) |
| MillerIndex | gt (const MillerIndex &a, const Scalar &b) |
| MillerIndex | gt (const Scalar &a, const MillerIndex &b) |
| MillerIndex | lt (const MillerIndex &a, const Scalar &b) |
| MillerIndex | lt (const Scalar &a, const MillerIndex &b) |
| MillerIndex | ge (const MillerIndex &a, const Scalar &b) |
| MillerIndex | ge (const Scalar &a, const MillerIndex &b) |
| MillerIndex | le (const MillerIndex &a, const Scalar &b) |
| MillerIndex | le (const Scalar &a, const MillerIndex &b) |
| MillerIndex | logical_and (const MillerIndex &a, const Scalar &b) |
| MillerIndex | logical_and (const Scalar &a, const MillerIndex &b) |
| MillerIndex | logical_or (const MillerIndex &a, const Scalar &b) |
| MillerIndex | logical_or (const Scalar &a, const MillerIndex &b) |
| MillerIndex | logical_xor (const MillerIndex &a, const Scalar &b) |
| MillerIndex | logical_xor (const Scalar &a, const MillerIndex &b) |
| MillerIndex | eq (const MillerIndex &a, const Scalar &b) |
| MillerIndex | eq (const Scalar &a, const MillerIndex &b) |
| MillerIndex | ne (const MillerIndex &a, const Scalar &b) |
| MillerIndex | ne (const Scalar &a, const MillerIndex &b) |
| Vec | operator> (const Vec &a, const CScalar &b) |
| Vec | operator> (const CScalar &a, const Vec &b) |
| Vec | operator< (const Vec &a, const CScalar &b) |
| Vec | operator< (const CScalar &a, const Vec &b) |
| Vec | operator>= (const Vec &a, const CScalar &b) |
| Vec | operator>= (const CScalar &a, const Vec &b) |
| Vec | operator<= (const Vec &a, const CScalar &b) |
| Vec | operator<= (const CScalar &a, const Vec &b) |
| Vec | operator&& (const Vec &a, const CScalar &b) |
| Vec | operator&& (const CScalar &a, const Vec &b) |
| Vec | operator|| (const Vec &a, const CScalar &b) |
| Vec | operator|| (const CScalar &a, const Vec &b) |
| Vec | operator== (const Vec &a, const CScalar &b) |
| Vec | operator== (const CScalar &a, const Vec &b) |
| Vec | operator!= (const Vec &a, const CScalar &b) |
| Vec | operator!= (const CScalar &a, const Vec &b) |
| Vec | gt (const Vec &a, const CScalar &b) |
| Vec | gt (const CScalar &a, const Vec &b) |
| Vec | lt (const Vec &a, const CScalar &b) |
| Vec | lt (const CScalar &a, const Vec &b) |
| Vec | ge (const Vec &a, const CScalar &b) |
| Vec | ge (const CScalar &a, const Vec &b) |
| Vec | le (const Vec &a, const CScalar &b) |
| Vec | le (const CScalar &a, const Vec &b) |
| Vec | logical_and (const Vec &a, const CScalar &b) |
| Vec | logical_and (const CScalar &a, const Vec &b) |
| Vec | logical_or (const Vec &a, const CScalar &b) |
| Vec | logical_or (const CScalar &a, const Vec &b) |
| Vec | logical_xor (const Vec &a, const CScalar &b) |
| Vec | logical_xor (const CScalar &a, const Vec &b) |
| Vec | eq (const Vec &a, const CScalar &b) |
| Vec | eq (const CScalar &a, const Vec &b) |
| Vec | ne (const Vec &a, const CScalar &b) |
| Vec | ne (const CScalar &a, const Vec &b) |
| Rot | operator> (const Rot &a, const CScalar &b) |
| Rot | operator> (const CScalar &a, const Rot &b) |
| Rot | operator< (const Rot &a, const CScalar &b) |
| Rot | operator< (const CScalar &a, const Rot &b) |
| Rot | operator>= (const Rot &a, const CScalar &b) |
| Rot | operator>= (const CScalar &a, const Rot &b) |
| Rot | operator<= (const Rot &a, const CScalar &b) |
| Rot | operator<= (const CScalar &a, const Rot &b) |
| Rot | operator&& (const Rot &a, const CScalar &b) |
| Rot | operator&& (const CScalar &a, const Rot &b) |
| Rot | operator|| (const Rot &a, const CScalar &b) |
| Rot | operator|| (const CScalar &a, const Rot &b) |
| Rot | operator== (const Rot &a, const CScalar &b) |
| Rot | operator== (const CScalar &a, const Rot &b) |
| Rot | operator!= (const Rot &a, const CScalar &b) |
| Rot | operator!= (const CScalar &a, const Rot &b) |
| Rot | gt (const Rot &a, const CScalar &b) |
| Rot | gt (const CScalar &a, const Rot &b) |
| Rot | lt (const Rot &a, const CScalar &b) |
| Rot | lt (const CScalar &a, const Rot &b) |
| Rot | ge (const Rot &a, const CScalar &b) |
| Rot | ge (const CScalar &a, const Rot &b) |
| Rot | le (const Rot &a, const CScalar &b) |
| Rot | le (const CScalar &a, const Rot &b) |
| Rot | logical_and (const Rot &a, const CScalar &b) |
| Rot | logical_and (const CScalar &a, const Rot &b) |
| Rot | logical_or (const Rot &a, const CScalar &b) |
| Rot | logical_or (const CScalar &a, const Rot &b) |
| Rot | logical_xor (const Rot &a, const CScalar &b) |
| Rot | logical_xor (const CScalar &a, const Rot &b) |
| Rot | eq (const Rot &a, const CScalar &b) |
| Rot | eq (const CScalar &a, const Rot &b) |
| Rot | ne (const Rot &a, const CScalar &b) |
| Rot | ne (const CScalar &a, const Rot &b) |
| WR2 | operator> (const WR2 &a, const CScalar &b) |
| WR2 | operator> (const CScalar &a, const WR2 &b) |
| WR2 | operator< (const WR2 &a, const CScalar &b) |
| WR2 | operator< (const CScalar &a, const WR2 &b) |
| WR2 | operator>= (const WR2 &a, const CScalar &b) |
| WR2 | operator>= (const CScalar &a, const WR2 &b) |
| WR2 | operator<= (const WR2 &a, const CScalar &b) |
| WR2 | operator<= (const CScalar &a, const WR2 &b) |
| WR2 | operator&& (const WR2 &a, const CScalar &b) |
| WR2 | operator&& (const CScalar &a, const WR2 &b) |
| WR2 | operator|| (const WR2 &a, const CScalar &b) |
| WR2 | operator|| (const CScalar &a, const WR2 &b) |
| WR2 | operator== (const WR2 &a, const CScalar &b) |
| WR2 | operator== (const CScalar &a, const WR2 &b) |
| WR2 | operator!= (const WR2 &a, const CScalar &b) |
| WR2 | operator!= (const CScalar &a, const WR2 &b) |
| WR2 | gt (const WR2 &a, const CScalar &b) |
| WR2 | gt (const CScalar &a, const WR2 &b) |
| WR2 | lt (const WR2 &a, const CScalar &b) |
| WR2 | lt (const CScalar &a, const WR2 &b) |
| WR2 | ge (const WR2 &a, const CScalar &b) |
| WR2 | ge (const CScalar &a, const WR2 &b) |
| WR2 | le (const WR2 &a, const CScalar &b) |
| WR2 | le (const CScalar &a, const WR2 &b) |
| WR2 | logical_and (const WR2 &a, const CScalar &b) |
| WR2 | logical_and (const CScalar &a, const WR2 &b) |
| WR2 | logical_or (const WR2 &a, const CScalar &b) |
| WR2 | logical_or (const CScalar &a, const WR2 &b) |
| WR2 | logical_xor (const WR2 &a, const CScalar &b) |
| WR2 | logical_xor (const CScalar &a, const WR2 &b) |
| WR2 | eq (const WR2 &a, const CScalar &b) |
| WR2 | eq (const CScalar &a, const WR2 &b) |
| WR2 | ne (const WR2 &a, const CScalar &b) |
| WR2 | ne (const CScalar &a, const WR2 &b) |
| R2 | operator> (const R2 &a, const CScalar &b) |
| R2 | operator> (const CScalar &a, const R2 &b) |
| R2 | operator< (const R2 &a, const CScalar &b) |
| R2 | operator< (const CScalar &a, const R2 &b) |
| R2 | operator>= (const R2 &a, const CScalar &b) |
| R2 | operator>= (const CScalar &a, const R2 &b) |
| R2 | operator<= (const R2 &a, const CScalar &b) |
| R2 | operator<= (const CScalar &a, const R2 &b) |
| R2 | operator&& (const R2 &a, const CScalar &b) |
| R2 | operator&& (const CScalar &a, const R2 &b) |
| R2 | operator|| (const R2 &a, const CScalar &b) |
| R2 | operator|| (const CScalar &a, const R2 &b) |
| R2 | operator== (const R2 &a, const CScalar &b) |
| R2 | operator== (const CScalar &a, const R2 &b) |
| R2 | operator!= (const R2 &a, const CScalar &b) |
| R2 | operator!= (const CScalar &a, const R2 &b) |
| R2 | gt (const R2 &a, const CScalar &b) |
| R2 | gt (const CScalar &a, const R2 &b) |
| R2 | lt (const R2 &a, const CScalar &b) |
| R2 | lt (const CScalar &a, const R2 &b) |
| R2 | ge (const R2 &a, const CScalar &b) |
| R2 | ge (const CScalar &a, const R2 &b) |
| R2 | le (const R2 &a, const CScalar &b) |
| R2 | le (const CScalar &a, const R2 &b) |
| R2 | logical_and (const R2 &a, const CScalar &b) |
| R2 | logical_and (const CScalar &a, const R2 &b) |
| R2 | logical_or (const R2 &a, const CScalar &b) |
| R2 | logical_or (const CScalar &a, const R2 &b) |
| R2 | logical_xor (const R2 &a, const CScalar &b) |
| R2 | logical_xor (const CScalar &a, const R2 &b) |
| R2 | eq (const R2 &a, const CScalar &b) |
| R2 | eq (const CScalar &a, const R2 &b) |
| R2 | ne (const R2 &a, const CScalar &b) |
| R2 | ne (const CScalar &a, const R2 &b) |
| SR2 | operator> (const SR2 &a, const CScalar &b) |
| SR2 | operator> (const CScalar &a, const SR2 &b) |
| SR2 | operator< (const SR2 &a, const CScalar &b) |
| SR2 | operator< (const CScalar &a, const SR2 &b) |
| SR2 | operator>= (const SR2 &a, const CScalar &b) |
| SR2 | operator>= (const CScalar &a, const SR2 &b) |
| SR2 | operator<= (const SR2 &a, const CScalar &b) |
| SR2 | operator<= (const CScalar &a, const SR2 &b) |
| SR2 | operator&& (const SR2 &a, const CScalar &b) |
| SR2 | operator&& (const CScalar &a, const SR2 &b) |
| SR2 | operator|| (const SR2 &a, const CScalar &b) |
| SR2 | operator|| (const CScalar &a, const SR2 &b) |
| SR2 | operator== (const SR2 &a, const CScalar &b) |
| SR2 | operator== (const CScalar &a, const SR2 &b) |
| SR2 | operator!= (const SR2 &a, const CScalar &b) |
| SR2 | operator!= (const CScalar &a, const SR2 &b) |
| SR2 | gt (const SR2 &a, const CScalar &b) |
| SR2 | gt (const CScalar &a, const SR2 &b) |
| SR2 | lt (const SR2 &a, const CScalar &b) |
| SR2 | lt (const CScalar &a, const SR2 &b) |
| SR2 | ge (const SR2 &a, const CScalar &b) |
| SR2 | ge (const CScalar &a, const SR2 &b) |
| SR2 | le (const SR2 &a, const CScalar &b) |
| SR2 | le (const CScalar &a, const SR2 &b) |
| SR2 | logical_and (const SR2 &a, const CScalar &b) |
| SR2 | logical_and (const CScalar &a, const SR2 &b) |
| SR2 | logical_or (const SR2 &a, const CScalar &b) |
| SR2 | logical_or (const CScalar &a, const SR2 &b) |
| SR2 | logical_xor (const SR2 &a, const CScalar &b) |
| SR2 | logical_xor (const CScalar &a, const SR2 &b) |
| SR2 | eq (const SR2 &a, const CScalar &b) |
| SR2 | eq (const CScalar &a, const SR2 &b) |
| SR2 | ne (const SR2 &a, const CScalar &b) |
| SR2 | ne (const CScalar &a, const SR2 &b) |
| R3 | operator> (const R3 &a, const CScalar &b) |
| R3 | operator> (const CScalar &a, const R3 &b) |
| R3 | operator< (const R3 &a, const CScalar &b) |
| R3 | operator< (const CScalar &a, const R3 &b) |
| R3 | operator>= (const R3 &a, const CScalar &b) |
| R3 | operator>= (const CScalar &a, const R3 &b) |
| R3 | operator<= (const R3 &a, const CScalar &b) |
| R3 | operator<= (const CScalar &a, const R3 &b) |
| R3 | operator&& (const R3 &a, const CScalar &b) |
| R3 | operator&& (const CScalar &a, const R3 &b) |
| R3 | operator|| (const R3 &a, const CScalar &b) |
| R3 | operator|| (const CScalar &a, const R3 &b) |
| R3 | operator== (const R3 &a, const CScalar &b) |
| R3 | operator== (const CScalar &a, const R3 &b) |
| R3 | operator!= (const R3 &a, const CScalar &b) |
| R3 | operator!= (const CScalar &a, const R3 &b) |
| R3 | gt (const R3 &a, const CScalar &b) |
| R3 | gt (const CScalar &a, const R3 &b) |
| R3 | lt (const R3 &a, const CScalar &b) |
| R3 | lt (const CScalar &a, const R3 &b) |
| R3 | ge (const R3 &a, const CScalar &b) |
| R3 | ge (const CScalar &a, const R3 &b) |
| R3 | le (const R3 &a, const CScalar &b) |
| R3 | le (const CScalar &a, const R3 &b) |
| R3 | logical_and (const R3 &a, const CScalar &b) |
| R3 | logical_and (const CScalar &a, const R3 &b) |
| R3 | logical_or (const R3 &a, const CScalar &b) |
| R3 | logical_or (const CScalar &a, const R3 &b) |
| R3 | logical_xor (const R3 &a, const CScalar &b) |
| R3 | logical_xor (const CScalar &a, const R3 &b) |
| R3 | eq (const R3 &a, const CScalar &b) |
| R3 | eq (const CScalar &a, const R3 &b) |
| R3 | ne (const R3 &a, const CScalar &b) |
| R3 | ne (const CScalar &a, const R3 &b) |
| SFR3 | operator> (const SFR3 &a, const CScalar &b) |
| SFR3 | operator> (const CScalar &a, const SFR3 &b) |
| SFR3 | operator< (const SFR3 &a, const CScalar &b) |
| SFR3 | operator< (const CScalar &a, const SFR3 &b) |
| SFR3 | operator>= (const SFR3 &a, const CScalar &b) |
| SFR3 | operator>= (const CScalar &a, const SFR3 &b) |
| SFR3 | operator<= (const SFR3 &a, const CScalar &b) |
| SFR3 | operator<= (const CScalar &a, const SFR3 &b) |
| SFR3 | operator&& (const SFR3 &a, const CScalar &b) |
| SFR3 | operator&& (const CScalar &a, const SFR3 &b) |
| SFR3 | operator|| (const SFR3 &a, const CScalar &b) |
| SFR3 | operator|| (const CScalar &a, const SFR3 &b) |
| SFR3 | operator== (const SFR3 &a, const CScalar &b) |
| SFR3 | operator== (const CScalar &a, const SFR3 &b) |
| SFR3 | operator!= (const SFR3 &a, const CScalar &b) |
| SFR3 | operator!= (const CScalar &a, const SFR3 &b) |
| SFR3 | gt (const SFR3 &a, const CScalar &b) |
| SFR3 | gt (const CScalar &a, const SFR3 &b) |
| SFR3 | lt (const SFR3 &a, const CScalar &b) |
| SFR3 | lt (const CScalar &a, const SFR3 &b) |
| SFR3 | ge (const SFR3 &a, const CScalar &b) |
| SFR3 | ge (const CScalar &a, const SFR3 &b) |
| SFR3 | le (const SFR3 &a, const CScalar &b) |
| SFR3 | le (const CScalar &a, const SFR3 &b) |
| SFR3 | logical_and (const SFR3 &a, const CScalar &b) |
| SFR3 | logical_and (const CScalar &a, const SFR3 &b) |
| SFR3 | logical_or (const SFR3 &a, const CScalar &b) |
| SFR3 | logical_or (const CScalar &a, const SFR3 &b) |
| SFR3 | logical_xor (const SFR3 &a, const CScalar &b) |
| SFR3 | logical_xor (const CScalar &a, const SFR3 &b) |
| SFR3 | eq (const SFR3 &a, const CScalar &b) |
| SFR3 | eq (const CScalar &a, const SFR3 &b) |
| SFR3 | ne (const SFR3 &a, const CScalar &b) |
| SFR3 | ne (const CScalar &a, const SFR3 &b) |
| R4 | operator> (const R4 &a, const CScalar &b) |
| R4 | operator> (const CScalar &a, const R4 &b) |
| R4 | operator< (const R4 &a, const CScalar &b) |
| R4 | operator< (const CScalar &a, const R4 &b) |
| R4 | operator>= (const R4 &a, const CScalar &b) |
| R4 | operator>= (const CScalar &a, const R4 &b) |
| R4 | operator<= (const R4 &a, const CScalar &b) |
| R4 | operator<= (const CScalar &a, const R4 &b) |
| R4 | operator&& (const R4 &a, const CScalar &b) |
| R4 | operator&& (const CScalar &a, const R4 &b) |
| R4 | operator|| (const R4 &a, const CScalar &b) |
| R4 | operator|| (const CScalar &a, const R4 &b) |
| R4 | operator== (const R4 &a, const CScalar &b) |
| R4 | operator== (const CScalar &a, const R4 &b) |
| R4 | operator!= (const R4 &a, const CScalar &b) |
| R4 | operator!= (const CScalar &a, const R4 &b) |
| R4 | gt (const R4 &a, const CScalar &b) |
| R4 | gt (const CScalar &a, const R4 &b) |
| R4 | lt (const R4 &a, const CScalar &b) |
| R4 | lt (const CScalar &a, const R4 &b) |
| R4 | ge (const R4 &a, const CScalar &b) |
| R4 | ge (const CScalar &a, const R4 &b) |
| R4 | le (const R4 &a, const CScalar &b) |
| R4 | le (const CScalar &a, const R4 &b) |
| R4 | logical_and (const R4 &a, const CScalar &b) |
| R4 | logical_and (const CScalar &a, const R4 &b) |
| R4 | logical_or (const R4 &a, const CScalar &b) |
| R4 | logical_or (const CScalar &a, const R4 &b) |
| R4 | logical_xor (const R4 &a, const CScalar &b) |
| R4 | logical_xor (const CScalar &a, const R4 &b) |
| R4 | eq (const R4 &a, const CScalar &b) |
| R4 | eq (const CScalar &a, const R4 &b) |
| R4 | ne (const R4 &a, const CScalar &b) |
| R4 | ne (const CScalar &a, const R4 &b) |
| SFFR4 | operator> (const SFFR4 &a, const CScalar &b) |
| SFFR4 | operator> (const CScalar &a, const SFFR4 &b) |
| SFFR4 | operator< (const SFFR4 &a, const CScalar &b) |
| SFFR4 | operator< (const CScalar &a, const SFFR4 &b) |
| SFFR4 | operator>= (const SFFR4 &a, const CScalar &b) |
| SFFR4 | operator>= (const CScalar &a, const SFFR4 &b) |
| SFFR4 | operator<= (const SFFR4 &a, const CScalar &b) |
| SFFR4 | operator<= (const CScalar &a, const SFFR4 &b) |
| SFFR4 | operator&& (const SFFR4 &a, const CScalar &b) |
| SFFR4 | operator&& (const CScalar &a, const SFFR4 &b) |
| SFFR4 | operator|| (const SFFR4 &a, const CScalar &b) |
| SFFR4 | operator|| (const CScalar &a, const SFFR4 &b) |
| SFFR4 | operator== (const SFFR4 &a, const CScalar &b) |
| SFFR4 | operator== (const CScalar &a, const SFFR4 &b) |
| SFFR4 | operator!= (const SFFR4 &a, const CScalar &b) |
| SFFR4 | operator!= (const CScalar &a, const SFFR4 &b) |
| SFFR4 | gt (const SFFR4 &a, const CScalar &b) |
| SFFR4 | gt (const CScalar &a, const SFFR4 &b) |
| SFFR4 | lt (const SFFR4 &a, const CScalar &b) |
| SFFR4 | lt (const CScalar &a, const SFFR4 &b) |
| SFFR4 | ge (const SFFR4 &a, const CScalar &b) |
| SFFR4 | ge (const CScalar &a, const SFFR4 &b) |
| SFFR4 | le (const SFFR4 &a, const CScalar &b) |
| SFFR4 | le (const CScalar &a, const SFFR4 &b) |
| SFFR4 | logical_and (const SFFR4 &a, const CScalar &b) |
| SFFR4 | logical_and (const CScalar &a, const SFFR4 &b) |
| SFFR4 | logical_or (const SFFR4 &a, const CScalar &b) |
| SFFR4 | logical_or (const CScalar &a, const SFFR4 &b) |
| SFFR4 | logical_xor (const SFFR4 &a, const CScalar &b) |
| SFFR4 | logical_xor (const CScalar &a, const SFFR4 &b) |
| SFFR4 | eq (const SFFR4 &a, const CScalar &b) |
| SFFR4 | eq (const CScalar &a, const SFFR4 &b) |
| SFFR4 | ne (const SFFR4 &a, const CScalar &b) |
| SFFR4 | ne (const CScalar &a, const SFFR4 &b) |
| WFFR4 | operator> (const WFFR4 &a, const CScalar &b) |
| WFFR4 | operator> (const CScalar &a, const WFFR4 &b) |
| WFFR4 | operator< (const WFFR4 &a, const CScalar &b) |
| WFFR4 | operator< (const CScalar &a, const WFFR4 &b) |
| WFFR4 | operator>= (const WFFR4 &a, const CScalar &b) |
| WFFR4 | operator>= (const CScalar &a, const WFFR4 &b) |
| WFFR4 | operator<= (const WFFR4 &a, const CScalar &b) |
| WFFR4 | operator<= (const CScalar &a, const WFFR4 &b) |
| WFFR4 | operator&& (const WFFR4 &a, const CScalar &b) |
| WFFR4 | operator&& (const CScalar &a, const WFFR4 &b) |
| WFFR4 | operator|| (const WFFR4 &a, const CScalar &b) |
| WFFR4 | operator|| (const CScalar &a, const WFFR4 &b) |
| WFFR4 | operator== (const WFFR4 &a, const CScalar &b) |
| WFFR4 | operator== (const CScalar &a, const WFFR4 &b) |
| WFFR4 | operator!= (const WFFR4 &a, const CScalar &b) |
| WFFR4 | operator!= (const CScalar &a, const WFFR4 &b) |
| WFFR4 | gt (const WFFR4 &a, const CScalar &b) |
| WFFR4 | gt (const CScalar &a, const WFFR4 &b) |
| WFFR4 | lt (const WFFR4 &a, const CScalar &b) |
| WFFR4 | lt (const CScalar &a, const WFFR4 &b) |
| WFFR4 | ge (const WFFR4 &a, const CScalar &b) |
| WFFR4 | ge (const CScalar &a, const WFFR4 &b) |
| WFFR4 | le (const WFFR4 &a, const CScalar &b) |
| WFFR4 | le (const CScalar &a, const WFFR4 &b) |
| WFFR4 | logical_and (const WFFR4 &a, const CScalar &b) |
| WFFR4 | logical_and (const CScalar &a, const WFFR4 &b) |
| WFFR4 | logical_or (const WFFR4 &a, const CScalar &b) |
| WFFR4 | logical_or (const CScalar &a, const WFFR4 &b) |
| WFFR4 | logical_xor (const WFFR4 &a, const CScalar &b) |
| WFFR4 | logical_xor (const CScalar &a, const WFFR4 &b) |
| WFFR4 | eq (const WFFR4 &a, const CScalar &b) |
| WFFR4 | eq (const CScalar &a, const WFFR4 &b) |
| WFFR4 | ne (const WFFR4 &a, const CScalar &b) |
| WFFR4 | ne (const CScalar &a, const WFFR4 &b) |
| SSR4 | operator> (const SSR4 &a, const CScalar &b) |
| SSR4 | operator> (const CScalar &a, const SSR4 &b) |
| SSR4 | operator< (const SSR4 &a, const CScalar &b) |
| SSR4 | operator< (const CScalar &a, const SSR4 &b) |
| SSR4 | operator>= (const SSR4 &a, const CScalar &b) |
| SSR4 | operator>= (const CScalar &a, const SSR4 &b) |
| SSR4 | operator<= (const SSR4 &a, const CScalar &b) |
| SSR4 | operator<= (const CScalar &a, const SSR4 &b) |
| SSR4 | operator&& (const SSR4 &a, const CScalar &b) |
| SSR4 | operator&& (const CScalar &a, const SSR4 &b) |
| SSR4 | operator|| (const SSR4 &a, const CScalar &b) |
| SSR4 | operator|| (const CScalar &a, const SSR4 &b) |
| SSR4 | operator== (const SSR4 &a, const CScalar &b) |
| SSR4 | operator== (const CScalar &a, const SSR4 &b) |
| SSR4 | operator!= (const SSR4 &a, const CScalar &b) |
| SSR4 | operator!= (const CScalar &a, const SSR4 &b) |
| SSR4 | gt (const SSR4 &a, const CScalar &b) |
| SSR4 | gt (const CScalar &a, const SSR4 &b) |
| SSR4 | lt (const SSR4 &a, const CScalar &b) |
| SSR4 | lt (const CScalar &a, const SSR4 &b) |
| SSR4 | ge (const SSR4 &a, const CScalar &b) |
| SSR4 | ge (const CScalar &a, const SSR4 &b) |
| SSR4 | le (const SSR4 &a, const CScalar &b) |
| SSR4 | le (const CScalar &a, const SSR4 &b) |
| SSR4 | logical_and (const SSR4 &a, const CScalar &b) |
| SSR4 | logical_and (const CScalar &a, const SSR4 &b) |
| SSR4 | logical_or (const SSR4 &a, const CScalar &b) |
| SSR4 | logical_or (const CScalar &a, const SSR4 &b) |
| SSR4 | logical_xor (const SSR4 &a, const CScalar &b) |
| SSR4 | logical_xor (const CScalar &a, const SSR4 &b) |
| SSR4 | eq (const SSR4 &a, const CScalar &b) |
| SSR4 | eq (const CScalar &a, const SSR4 &b) |
| SSR4 | ne (const SSR4 &a, const CScalar &b) |
| SSR4 | ne (const CScalar &a, const SSR4 &b) |
| SWR4 | operator> (const SWR4 &a, const CScalar &b) |
| SWR4 | operator> (const CScalar &a, const SWR4 &b) |
| SWR4 | operator< (const SWR4 &a, const CScalar &b) |
| SWR4 | operator< (const CScalar &a, const SWR4 &b) |
| SWR4 | operator>= (const SWR4 &a, const CScalar &b) |
| SWR4 | operator>= (const CScalar &a, const SWR4 &b) |
| SWR4 | operator<= (const SWR4 &a, const CScalar &b) |
| SWR4 | operator<= (const CScalar &a, const SWR4 &b) |
| SWR4 | operator&& (const SWR4 &a, const CScalar &b) |
| SWR4 | operator&& (const CScalar &a, const SWR4 &b) |
| SWR4 | operator|| (const SWR4 &a, const CScalar &b) |
| SWR4 | operator|| (const CScalar &a, const SWR4 &b) |
| SWR4 | operator== (const SWR4 &a, const CScalar &b) |
| SWR4 | operator== (const CScalar &a, const SWR4 &b) |
| SWR4 | operator!= (const SWR4 &a, const CScalar &b) |
| SWR4 | operator!= (const CScalar &a, const SWR4 &b) |
| SWR4 | gt (const SWR4 &a, const CScalar &b) |
| SWR4 | gt (const CScalar &a, const SWR4 &b) |
| SWR4 | lt (const SWR4 &a, const CScalar &b) |
| SWR4 | lt (const CScalar &a, const SWR4 &b) |
| SWR4 | ge (const SWR4 &a, const CScalar &b) |
| SWR4 | ge (const CScalar &a, const SWR4 &b) |
| SWR4 | le (const SWR4 &a, const CScalar &b) |
| SWR4 | le (const CScalar &a, const SWR4 &b) |
| SWR4 | logical_and (const SWR4 &a, const CScalar &b) |
| SWR4 | logical_and (const CScalar &a, const SWR4 &b) |
| SWR4 | logical_or (const SWR4 &a, const CScalar &b) |
| SWR4 | logical_or (const CScalar &a, const SWR4 &b) |
| SWR4 | logical_xor (const SWR4 &a, const CScalar &b) |
| SWR4 | logical_xor (const CScalar &a, const SWR4 &b) |
| SWR4 | eq (const SWR4 &a, const CScalar &b) |
| SWR4 | eq (const CScalar &a, const SWR4 &b) |
| SWR4 | ne (const SWR4 &a, const CScalar &b) |
| SWR4 | ne (const CScalar &a, const SWR4 &b) |
| WSR4 | operator> (const WSR4 &a, const CScalar &b) |
| WSR4 | operator> (const CScalar &a, const WSR4 &b) |
| WSR4 | operator< (const WSR4 &a, const CScalar &b) |
| WSR4 | operator< (const CScalar &a, const WSR4 &b) |
| WSR4 | operator>= (const WSR4 &a, const CScalar &b) |
| WSR4 | operator>= (const CScalar &a, const WSR4 &b) |
| WSR4 | operator<= (const WSR4 &a, const CScalar &b) |
| WSR4 | operator<= (const CScalar &a, const WSR4 &b) |
| WSR4 | operator&& (const WSR4 &a, const CScalar &b) |
| WSR4 | operator&& (const CScalar &a, const WSR4 &b) |
| WSR4 | operator|| (const WSR4 &a, const CScalar &b) |
| WSR4 | operator|| (const CScalar &a, const WSR4 &b) |
| WSR4 | operator== (const WSR4 &a, const CScalar &b) |
| WSR4 | operator== (const CScalar &a, const WSR4 &b) |
| WSR4 | operator!= (const WSR4 &a, const CScalar &b) |
| WSR4 | operator!= (const CScalar &a, const WSR4 &b) |
| WSR4 | gt (const WSR4 &a, const CScalar &b) |
| WSR4 | gt (const CScalar &a, const WSR4 &b) |
| WSR4 | lt (const WSR4 &a, const CScalar &b) |
| WSR4 | lt (const CScalar &a, const WSR4 &b) |
| WSR4 | ge (const WSR4 &a, const CScalar &b) |
| WSR4 | ge (const CScalar &a, const WSR4 &b) |
| WSR4 | le (const WSR4 &a, const CScalar &b) |
| WSR4 | le (const CScalar &a, const WSR4 &b) |
| WSR4 | logical_and (const WSR4 &a, const CScalar &b) |
| WSR4 | logical_and (const CScalar &a, const WSR4 &b) |
| WSR4 | logical_or (const WSR4 &a, const CScalar &b) |
| WSR4 | logical_or (const CScalar &a, const WSR4 &b) |
| WSR4 | logical_xor (const WSR4 &a, const CScalar &b) |
| WSR4 | logical_xor (const CScalar &a, const WSR4 &b) |
| WSR4 | eq (const WSR4 &a, const CScalar &b) |
| WSR4 | eq (const CScalar &a, const WSR4 &b) |
| WSR4 | ne (const WSR4 &a, const CScalar &b) |
| WSR4 | ne (const CScalar &a, const WSR4 &b) |
| WWR4 | operator> (const WWR4 &a, const CScalar &b) |
| WWR4 | operator> (const CScalar &a, const WWR4 &b) |
| WWR4 | operator< (const WWR4 &a, const CScalar &b) |
| WWR4 | operator< (const CScalar &a, const WWR4 &b) |
| WWR4 | operator>= (const WWR4 &a, const CScalar &b) |
| WWR4 | operator>= (const CScalar &a, const WWR4 &b) |
| WWR4 | operator<= (const WWR4 &a, const CScalar &b) |
| WWR4 | operator<= (const CScalar &a, const WWR4 &b) |
| WWR4 | operator&& (const WWR4 &a, const CScalar &b) |
| WWR4 | operator&& (const CScalar &a, const WWR4 &b) |
| WWR4 | operator|| (const WWR4 &a, const CScalar &b) |
| WWR4 | operator|| (const CScalar &a, const WWR4 &b) |
| WWR4 | operator== (const WWR4 &a, const CScalar &b) |
| WWR4 | operator== (const CScalar &a, const WWR4 &b) |
| WWR4 | operator!= (const WWR4 &a, const CScalar &b) |
| WWR4 | operator!= (const CScalar &a, const WWR4 &b) |
| WWR4 | gt (const WWR4 &a, const CScalar &b) |
| WWR4 | gt (const CScalar &a, const WWR4 &b) |
| WWR4 | lt (const WWR4 &a, const CScalar &b) |
| WWR4 | lt (const CScalar &a, const WWR4 &b) |
| WWR4 | ge (const WWR4 &a, const CScalar &b) |
| WWR4 | ge (const CScalar &a, const WWR4 &b) |
| WWR4 | le (const WWR4 &a, const CScalar &b) |
| WWR4 | le (const CScalar &a, const WWR4 &b) |
| WWR4 | logical_and (const WWR4 &a, const CScalar &b) |
| WWR4 | logical_and (const CScalar &a, const WWR4 &b) |
| WWR4 | logical_or (const WWR4 &a, const CScalar &b) |
| WWR4 | logical_or (const CScalar &a, const WWR4 &b) |
| WWR4 | logical_xor (const WWR4 &a, const CScalar &b) |
| WWR4 | logical_xor (const CScalar &a, const WWR4 &b) |
| WWR4 | eq (const WWR4 &a, const CScalar &b) |
| WWR4 | eq (const CScalar &a, const WWR4 &b) |
| WWR4 | ne (const WWR4 &a, const CScalar &b) |
| WWR4 | ne (const CScalar &a, const WWR4 &b) |
| Quaternion | operator> (const Quaternion &a, const CScalar &b) |
| Quaternion | operator> (const CScalar &a, const Quaternion &b) |
| Quaternion | operator< (const Quaternion &a, const CScalar &b) |
| Quaternion | operator< (const CScalar &a, const Quaternion &b) |
| Quaternion | operator>= (const Quaternion &a, const CScalar &b) |
| Quaternion | operator>= (const CScalar &a, const Quaternion &b) |
| Quaternion | operator<= (const Quaternion &a, const CScalar &b) |
| Quaternion | operator<= (const CScalar &a, const Quaternion &b) |
| Quaternion | operator&& (const Quaternion &a, const CScalar &b) |
| Quaternion | operator&& (const CScalar &a, const Quaternion &b) |
| Quaternion | operator|| (const Quaternion &a, const CScalar &b) |
| Quaternion | operator|| (const CScalar &a, const Quaternion &b) |
| Quaternion | operator== (const Quaternion &a, const CScalar &b) |
| Quaternion | operator== (const CScalar &a, const Quaternion &b) |
| Quaternion | operator!= (const Quaternion &a, const CScalar &b) |
| Quaternion | operator!= (const CScalar &a, const Quaternion &b) |
| Quaternion | gt (const Quaternion &a, const CScalar &b) |
| Quaternion | gt (const CScalar &a, const Quaternion &b) |
| Quaternion | lt (const Quaternion &a, const CScalar &b) |
| Quaternion | lt (const CScalar &a, const Quaternion &b) |
| Quaternion | ge (const Quaternion &a, const CScalar &b) |
| Quaternion | ge (const CScalar &a, const Quaternion &b) |
| Quaternion | le (const Quaternion &a, const CScalar &b) |
| Quaternion | le (const CScalar &a, const Quaternion &b) |
| Quaternion | logical_and (const Quaternion &a, const CScalar &b) |
| Quaternion | logical_and (const CScalar &a, const Quaternion &b) |
| Quaternion | logical_or (const Quaternion &a, const CScalar &b) |
| Quaternion | logical_or (const CScalar &a, const Quaternion &b) |
| Quaternion | logical_xor (const Quaternion &a, const CScalar &b) |
| Quaternion | logical_xor (const CScalar &a, const Quaternion &b) |
| Quaternion | eq (const Quaternion &a, const CScalar &b) |
| Quaternion | eq (const CScalar &a, const Quaternion &b) |
| Quaternion | ne (const Quaternion &a, const CScalar &b) |
| Quaternion | ne (const CScalar &a, const Quaternion &b) |
| MillerIndex | operator> (const MillerIndex &a, const CScalar &b) |
| MillerIndex | operator> (const CScalar &a, const MillerIndex &b) |
| MillerIndex | operator< (const MillerIndex &a, const CScalar &b) |
| MillerIndex | operator< (const CScalar &a, const MillerIndex &b) |
| MillerIndex | operator>= (const MillerIndex &a, const CScalar &b) |
| MillerIndex | operator>= (const CScalar &a, const MillerIndex &b) |
| MillerIndex | operator<= (const MillerIndex &a, const CScalar &b) |
| MillerIndex | operator<= (const CScalar &a, const MillerIndex &b) |
| MillerIndex | operator&& (const MillerIndex &a, const CScalar &b) |
| MillerIndex | operator&& (const CScalar &a, const MillerIndex &b) |
| MillerIndex | operator|| (const MillerIndex &a, const CScalar &b) |
| MillerIndex | operator|| (const CScalar &a, const MillerIndex &b) |
| MillerIndex | operator== (const MillerIndex &a, const CScalar &b) |
| MillerIndex | operator== (const CScalar &a, const MillerIndex &b) |
| MillerIndex | operator!= (const MillerIndex &a, const CScalar &b) |
| MillerIndex | operator!= (const CScalar &a, const MillerIndex &b) |
| MillerIndex | gt (const MillerIndex &a, const CScalar &b) |
| MillerIndex | gt (const CScalar &a, const MillerIndex &b) |
| MillerIndex | lt (const MillerIndex &a, const CScalar &b) |
| MillerIndex | lt (const CScalar &a, const MillerIndex &b) |
| MillerIndex | ge (const MillerIndex &a, const CScalar &b) |
| MillerIndex | ge (const CScalar &a, const MillerIndex &b) |
| MillerIndex | le (const MillerIndex &a, const CScalar &b) |
| MillerIndex | le (const CScalar &a, const MillerIndex &b) |
| MillerIndex | logical_and (const MillerIndex &a, const CScalar &b) |
| MillerIndex | logical_and (const CScalar &a, const MillerIndex &b) |
| MillerIndex | logical_or (const MillerIndex &a, const CScalar &b) |
| MillerIndex | logical_or (const CScalar &a, const MillerIndex &b) |
| MillerIndex | logical_xor (const MillerIndex &a, const CScalar &b) |
| MillerIndex | logical_xor (const CScalar &a, const MillerIndex &b) |
| MillerIndex | eq (const MillerIndex &a, const CScalar &b) |
| MillerIndex | eq (const CScalar &a, const MillerIndex &b) |
| MillerIndex | ne (const MillerIndex &a, const CScalar &b) |
| MillerIndex | ne (const CScalar &a, const MillerIndex &b) |
| Tensor | operator> (const Tensor &a, const Tensor &b) |
| Tensor | operator< (const Tensor &a, const Tensor &b) |
| Tensor | operator>= (const Tensor &a, const Tensor &b) |
| Tensor | operator<= (const Tensor &a, const Tensor &b) |
| Tensor | operator&& (const Tensor &a, const Tensor &b) |
| Tensor | operator|| (const Tensor &a, const Tensor &b) |
| Tensor | operator== (const Tensor &a, const Tensor &b) |
| Tensor | operator!= (const Tensor &a, const Tensor &b) |
| Tensor | gt (const Tensor &a, const Tensor &b) |
| Tensor | lt (const Tensor &a, const Tensor &b) |
| Tensor | ge (const Tensor &a, const Tensor &b) |
| Tensor | le (const Tensor &a, const Tensor &b) |
| Tensor | logical_and (const Tensor &a, const Tensor &b) |
| Tensor | logical_or (const Tensor &a, const Tensor &b) |
| Tensor | logical_xor (const Tensor &a, const Tensor &b) |
| Tensor | eq (const Tensor &a, const Tensor &b) |
| Tensor | ne (const Tensor &a, const Tensor &b) |
| Tensor | operator! (const Tensor &a) |
| Tensor | logical_not (const Tensor &a) |
| Tensor | operator> (const Tensor &a, const Scalar &b) |
| Tensor | operator> (const Scalar &a, const Tensor &b) |
| Tensor | operator< (const Tensor &a, const Scalar &b) |
| Tensor | operator< (const Scalar &a, const Tensor &b) |
| Tensor | operator>= (const Tensor &a, const Scalar &b) |
| Tensor | operator>= (const Scalar &a, const Tensor &b) |
| Tensor | operator<= (const Tensor &a, const Scalar &b) |
| Tensor | operator<= (const Scalar &a, const Tensor &b) |
| Tensor | operator&& (const Tensor &a, const Scalar &b) |
| Tensor | operator&& (const Scalar &a, const Tensor &b) |
| Tensor | operator|| (const Tensor &a, const Scalar &b) |
| Tensor | operator|| (const Scalar &a, const Tensor &b) |
| Tensor | operator== (const Tensor &a, const Scalar &b) |
| Tensor | operator== (const Scalar &a, const Tensor &b) |
| Tensor | operator!= (const Tensor &a, const Scalar &b) |
| Tensor | operator!= (const Scalar &a, const Tensor &b) |
| Tensor | gt (const Tensor &a, const Scalar &b) |
| Tensor | gt (const Scalar &a, const Tensor &b) |
| Tensor | lt (const Tensor &a, const Scalar &b) |
| Tensor | lt (const Scalar &a, const Tensor &b) |
| Tensor | ge (const Tensor &a, const Scalar &b) |
| Tensor | ge (const Scalar &a, const Tensor &b) |
| Tensor | le (const Tensor &a, const Scalar &b) |
| Tensor | le (const Scalar &a, const Tensor &b) |
| Tensor | logical_and (const Tensor &a, const Scalar &b) |
| Tensor | logical_and (const Scalar &a, const Tensor &b) |
| Tensor | logical_or (const Tensor &a, const Scalar &b) |
| Tensor | logical_or (const Scalar &a, const Tensor &b) |
| Tensor | logical_xor (const Tensor &a, const Scalar &b) |
| Tensor | logical_xor (const Scalar &a, const Tensor &b) |
| Tensor | eq (const Tensor &a, const Scalar &b) |
| Tensor | eq (const Scalar &a, const Tensor &b) |
| Tensor | ne (const Tensor &a, const Scalar &b) |
| Tensor | ne (const Scalar &a, const Tensor &b) |
| Tensor | operator> (const Tensor &a, const CScalar &b) |
| Tensor | operator> (const CScalar &a, const Tensor &b) |
| Tensor | operator< (const Tensor &a, const CScalar &b) |
| Tensor | operator< (const CScalar &a, const Tensor &b) |
| Tensor | operator>= (const Tensor &a, const CScalar &b) |
| Tensor | operator>= (const CScalar &a, const Tensor &b) |
| Tensor | operator<= (const Tensor &a, const CScalar &b) |
| Tensor | operator<= (const CScalar &a, const Tensor &b) |
| Tensor | operator&& (const Tensor &a, const CScalar &b) |
| Tensor | operator&& (const CScalar &a, const Tensor &b) |
| Tensor | operator|| (const Tensor &a, const CScalar &b) |
| Tensor | operator|| (const CScalar &a, const Tensor &b) |
| Tensor | operator== (const Tensor &a, const CScalar &b) |
| Tensor | operator== (const CScalar &a, const Tensor &b) |
| Tensor | operator!= (const Tensor &a, const CScalar &b) |
| Tensor | operator!= (const CScalar &a, const Tensor &b) |
| Tensor | gt (const Tensor &a, const CScalar &b) |
| Tensor | gt (const CScalar &a, const Tensor &b) |
| Tensor | lt (const Tensor &a, const CScalar &b) |
| Tensor | lt (const CScalar &a, const Tensor &b) |
| Tensor | ge (const Tensor &a, const CScalar &b) |
| Tensor | ge (const CScalar &a, const Tensor &b) |
| Tensor | le (const Tensor &a, const CScalar &b) |
| Tensor | le (const CScalar &a, const Tensor &b) |
| Tensor | logical_and (const Tensor &a, const CScalar &b) |
| Tensor | logical_and (const CScalar &a, const Tensor &b) |
| Tensor | logical_or (const Tensor &a, const CScalar &b) |
| Tensor | logical_or (const CScalar &a, const Tensor &b) |
| Tensor | logical_xor (const Tensor &a, const CScalar &b) |
| Tensor | logical_xor (const CScalar &a, const Tensor &b) |
| Tensor | eq (const Tensor &a, const CScalar &b) |
| Tensor | eq (const CScalar &a, const Tensor &b) |
| Tensor | ne (const Tensor &a, const CScalar &b) |
| Tensor | ne (const CScalar &a, const Tensor &b) |
| Scalar | operator> (const Scalar &a, const Scalar &b) |
| Scalar | operator< (const Scalar &a, const Scalar &b) |
| Scalar | operator>= (const Scalar &a, const Scalar &b) |
| Scalar | operator<= (const Scalar &a, const Scalar &b) |
| Scalar | operator&& (const Scalar &a, const Scalar &b) |
| Scalar | operator|| (const Scalar &a, const Scalar &b) |
| Scalar | operator== (const Scalar &a, const Scalar &b) |
| Scalar | operator!= (const Scalar &a, const Scalar &b) |
| Scalar | gt (const Scalar &a, const Scalar &b) |
| Scalar | lt (const Scalar &a, const Scalar &b) |
| Scalar | ge (const Scalar &a, const Scalar &b) |
| Scalar | le (const Scalar &a, const Scalar &b) |
| Scalar | logical_and (const Scalar &a, const Scalar &b) |
| Scalar | logical_or (const Scalar &a, const Scalar &b) |
| Scalar | logical_xor (const Scalar &a, const Scalar &b) |
| Scalar | eq (const Scalar &a, const Scalar &b) |
| Scalar | ne (const Scalar &a, const Scalar &b) |
| Scalar | operator! (const Scalar &a) |
| Scalar | logical_not (const Scalar &a) |
| Scalar | operator> (const Scalar &a, const CScalar &b) |
| Scalar | operator> (const CScalar &a, const Scalar &b) |
| Scalar | operator< (const Scalar &a, const CScalar &b) |
| Scalar | operator< (const CScalar &a, const Scalar &b) |
| Scalar | operator>= (const Scalar &a, const CScalar &b) |
| Scalar | operator>= (const CScalar &a, const Scalar &b) |
| Scalar | operator<= (const Scalar &a, const CScalar &b) |
| Scalar | operator<= (const CScalar &a, const Scalar &b) |
| Scalar | operator&& (const Scalar &a, const CScalar &b) |
| Scalar | operator&& (const CScalar &a, const Scalar &b) |
| Scalar | operator|| (const Scalar &a, const CScalar &b) |
| Scalar | operator|| (const CScalar &a, const Scalar &b) |
| Scalar | operator== (const Scalar &a, const CScalar &b) |
| Scalar | operator== (const CScalar &a, const Scalar &b) |
| Scalar | operator!= (const Scalar &a, const CScalar &b) |
| Scalar | operator!= (const CScalar &a, const Scalar &b) |
| Scalar | gt (const Scalar &a, const CScalar &b) |
| Scalar | gt (const CScalar &a, const Scalar &b) |
| Scalar | lt (const Scalar &a, const CScalar &b) |
| Scalar | lt (const CScalar &a, const Scalar &b) |
| Scalar | ge (const Scalar &a, const CScalar &b) |
| Scalar | ge (const CScalar &a, const Scalar &b) |
| Scalar | le (const Scalar &a, const CScalar &b) |
| Scalar | le (const CScalar &a, const Scalar &b) |
| Scalar | logical_and (const Scalar &a, const CScalar &b) |
| Scalar | logical_and (const CScalar &a, const Scalar &b) |
| Scalar | logical_or (const Scalar &a, const CScalar &b) |
| Scalar | logical_or (const CScalar &a, const Scalar &b) |
| Scalar | logical_xor (const Scalar &a, const CScalar &b) |
| Scalar | logical_xor (const CScalar &a, const Scalar &b) |
| Scalar | eq (const Scalar &a, const CScalar &b) |
| Scalar | eq (const CScalar &a, const Scalar &b) |
| Scalar | ne (const Scalar &a, const CScalar &b) |
| Scalar | ne (const CScalar &a, const Scalar &b) |
| Vec | macaulay (const Vec &a) |
| Rot | macaulay (const Rot &a) |
| WR2 | macaulay (const WR2 &a) |
| R2 | macaulay (const R2 &a) |
| SR2 | macaulay (const SR2 &a) |
| R3 | macaulay (const R3 &a) |
| SFR3 | macaulay (const SFR3 &a) |
| R4 | macaulay (const R4 &a) |
| SFFR4 | macaulay (const SFFR4 &a) |
| WFFR4 | macaulay (const WFFR4 &a) |
| SSR4 | macaulay (const SSR4 &a) |
| SWR4 | macaulay (const SWR4 &a) |
| WSR4 | macaulay (const WSR4 &a) |
| WWR4 | macaulay (const WWR4 &a) |
| Quaternion | macaulay (const Quaternion &a) |
| MillerIndex | macaulay (const MillerIndex &a) |
| Tensor | macaulay (const Tensor &a) |
| Scalar | macaulay (const Scalar &a) |
| Vec | dynamic_max (const Vec &a, Size d=0) |
| Vec | intmd_max (const Vec &a, Size d=0) |
| Rot | dynamic_max (const Rot &a, Size d=0) |
| Rot | intmd_max (const Rot &a, Size d=0) |
| WR2 | dynamic_max (const WR2 &a, Size d=0) |
| WR2 | intmd_max (const WR2 &a, Size d=0) |
| R2 | dynamic_max (const R2 &a, Size d=0) |
| R2 | intmd_max (const R2 &a, Size d=0) |
| SR2 | dynamic_max (const SR2 &a, Size d=0) |
| SR2 | intmd_max (const SR2 &a, Size d=0) |
| R3 | dynamic_max (const R3 &a, Size d=0) |
| R3 | intmd_max (const R3 &a, Size d=0) |
| SFR3 | dynamic_max (const SFR3 &a, Size d=0) |
| SFR3 | intmd_max (const SFR3 &a, Size d=0) |
| R4 | dynamic_max (const R4 &a, Size d=0) |
| R4 | intmd_max (const R4 &a, Size d=0) |
| SFFR4 | dynamic_max (const SFFR4 &a, Size d=0) |
| SFFR4 | intmd_max (const SFFR4 &a, Size d=0) |
| WFFR4 | dynamic_max (const WFFR4 &a, Size d=0) |
| WFFR4 | intmd_max (const WFFR4 &a, Size d=0) |
| SSR4 | dynamic_max (const SSR4 &a, Size d=0) |
| SSR4 | intmd_max (const SSR4 &a, Size d=0) |
| SWR4 | dynamic_max (const SWR4 &a, Size d=0) |
| SWR4 | intmd_max (const SWR4 &a, Size d=0) |
| WSR4 | dynamic_max (const WSR4 &a, Size d=0) |
| WSR4 | intmd_max (const WSR4 &a, Size d=0) |
| WWR4 | dynamic_max (const WWR4 &a, Size d=0) |
| WWR4 | intmd_max (const WWR4 &a, Size d=0) |
| Quaternion | dynamic_max (const Quaternion &a, Size d=0) |
| Quaternion | intmd_max (const Quaternion &a, Size d=0) |
| MillerIndex | dynamic_max (const MillerIndex &a, Size d=0) |
| MillerIndex | intmd_max (const MillerIndex &a, Size d=0) |
| Tensor | dynamic_max (const Tensor &a, Size d=0) |
| Tensor | intmd_max (const Tensor &a, Size d=0) |
| Scalar | dynamic_max (const Scalar &a, Size d=0) |
| Scalar | intmd_max (const Scalar &a, Size d=0) |
| Tensor | base_max (const Tensor &a, Size d=0) |
| Vec | dynamic_mean (const Vec &a, Size d=0) |
| Vec | intmd_mean (const Vec &a, Size d=0) |
| Rot | dynamic_mean (const Rot &a, Size d=0) |
| Rot | intmd_mean (const Rot &a, Size d=0) |
| WR2 | dynamic_mean (const WR2 &a, Size d=0) |
| WR2 | intmd_mean (const WR2 &a, Size d=0) |
| R2 | dynamic_mean (const R2 &a, Size d=0) |
| R2 | intmd_mean (const R2 &a, Size d=0) |
| SR2 | dynamic_mean (const SR2 &a, Size d=0) |
| SR2 | intmd_mean (const SR2 &a, Size d=0) |
| R3 | dynamic_mean (const R3 &a, Size d=0) |
| R3 | intmd_mean (const R3 &a, Size d=0) |
| SFR3 | dynamic_mean (const SFR3 &a, Size d=0) |
| SFR3 | intmd_mean (const SFR3 &a, Size d=0) |
| R4 | dynamic_mean (const R4 &a, Size d=0) |
| R4 | intmd_mean (const R4 &a, Size d=0) |
| SFFR4 | dynamic_mean (const SFFR4 &a, Size d=0) |
| SFFR4 | intmd_mean (const SFFR4 &a, Size d=0) |
| WFFR4 | dynamic_mean (const WFFR4 &a, Size d=0) |
| WFFR4 | intmd_mean (const WFFR4 &a, Size d=0) |
| SSR4 | dynamic_mean (const SSR4 &a, Size d=0) |
| SSR4 | intmd_mean (const SSR4 &a, Size d=0) |
| SWR4 | dynamic_mean (const SWR4 &a, Size d=0) |
| SWR4 | intmd_mean (const SWR4 &a, Size d=0) |
| WSR4 | dynamic_mean (const WSR4 &a, Size d=0) |
| WSR4 | intmd_mean (const WSR4 &a, Size d=0) |
| WWR4 | dynamic_mean (const WWR4 &a, Size d=0) |
| WWR4 | intmd_mean (const WWR4 &a, Size d=0) |
| Quaternion | dynamic_mean (const Quaternion &a, Size d=0) |
| Quaternion | intmd_mean (const Quaternion &a, Size d=0) |
| MillerIndex | dynamic_mean (const MillerIndex &a, Size d=0) |
| MillerIndex | intmd_mean (const MillerIndex &a, Size d=0) |
| Tensor | dynamic_mean (const Tensor &a, Size d=0) |
| Tensor | intmd_mean (const Tensor &a, Size d=0) |
| Scalar | dynamic_mean (const Scalar &a, Size d=0) |
| Scalar | intmd_mean (const Scalar &a, Size d=0) |
| Tensor | base_mean (const Tensor &a, Size d=0) |
| Vec | dynamic_min (const Vec &a, Size d=0) |
| Vec | intmd_min (const Vec &a, Size d=0) |
| Rot | dynamic_min (const Rot &a, Size d=0) |
| Rot | intmd_min (const Rot &a, Size d=0) |
| WR2 | dynamic_min (const WR2 &a, Size d=0) |
| WR2 | intmd_min (const WR2 &a, Size d=0) |
| R2 | dynamic_min (const R2 &a, Size d=0) |
| R2 | intmd_min (const R2 &a, Size d=0) |
| SR2 | dynamic_min (const SR2 &a, Size d=0) |
| SR2 | intmd_min (const SR2 &a, Size d=0) |
| R3 | dynamic_min (const R3 &a, Size d=0) |
| R3 | intmd_min (const R3 &a, Size d=0) |
| SFR3 | dynamic_min (const SFR3 &a, Size d=0) |
| SFR3 | intmd_min (const SFR3 &a, Size d=0) |
| R4 | dynamic_min (const R4 &a, Size d=0) |
| R4 | intmd_min (const R4 &a, Size d=0) |
| SFFR4 | dynamic_min (const SFFR4 &a, Size d=0) |
| SFFR4 | intmd_min (const SFFR4 &a, Size d=0) |
| WFFR4 | dynamic_min (const WFFR4 &a, Size d=0) |
| WFFR4 | intmd_min (const WFFR4 &a, Size d=0) |
| SSR4 | dynamic_min (const SSR4 &a, Size d=0) |
| SSR4 | intmd_min (const SSR4 &a, Size d=0) |
| SWR4 | dynamic_min (const SWR4 &a, Size d=0) |
| SWR4 | intmd_min (const SWR4 &a, Size d=0) |
| WSR4 | dynamic_min (const WSR4 &a, Size d=0) |
| WSR4 | intmd_min (const WSR4 &a, Size d=0) |
| WWR4 | dynamic_min (const WWR4 &a, Size d=0) |
| WWR4 | intmd_min (const WWR4 &a, Size d=0) |
| Quaternion | dynamic_min (const Quaternion &a, Size d=0) |
| Quaternion | intmd_min (const Quaternion &a, Size d=0) |
| MillerIndex | dynamic_min (const MillerIndex &a, Size d=0) |
| MillerIndex | intmd_min (const MillerIndex &a, Size d=0) |
| Tensor | dynamic_min (const Tensor &a, Size d=0) |
| Tensor | intmd_min (const Tensor &a, Size d=0) |
| Scalar | dynamic_min (const Scalar &a, Size d=0) |
| Scalar | intmd_min (const Scalar &a, Size d=0) |
| Tensor | base_min (const Tensor &a, Size d=0) |
| Vec | minimum (const Vec &a, const Vec &b) |
| Rot | minimum (const Rot &a, const Rot &b) |
| WR2 | minimum (const WR2 &a, const WR2 &b) |
| R2 | minimum (const R2 &a, const R2 &b) |
| SR2 | minimum (const SR2 &a, const SR2 &b) |
| R3 | minimum (const R3 &a, const R3 &b) |
| SFR3 | minimum (const SFR3 &a, const SFR3 &b) |
| R4 | minimum (const R4 &a, const R4 &b) |
| SFFR4 | minimum (const SFFR4 &a, const SFFR4 &b) |
| WFFR4 | minimum (const WFFR4 &a, const WFFR4 &b) |
| SSR4 | minimum (const SSR4 &a, const SSR4 &b) |
| SWR4 | minimum (const SWR4 &a, const SWR4 &b) |
| WSR4 | minimum (const WSR4 &a, const WSR4 &b) |
| WWR4 | minimum (const WWR4 &a, const WWR4 &b) |
| Quaternion | minimum (const Quaternion &a, const Quaternion &b) |
| MillerIndex | minimum (const MillerIndex &a, const MillerIndex &b) |
| Tensor | minimum (const Tensor &a, const Tensor &b) |
| Scalar | minimum (const Scalar &a, const Scalar &b) |
| Tensor | mm (const Tensor &a, const Tensor &b) |
| | Batched matrix-matrix product.
|
| Tensor | mv (const Tensor &a, const Tensor &v) |
| | Batched matrix-vector product.
|
| Scalar | norm (const Tensor &a, const std::optional< CScalar > &eps=std::nullopt) |
| | Frobenius norm of a tensor.
|
| Scalar | norm_sq (const Tensor &a) |
| | Squared Frobenius norm of a tensor.
|
| Vec | operator+ (const Vec &a, const Vec &b) |
| Rot | operator+ (const Rot &a, const Rot &b) |
| WR2 | operator+ (const WR2 &a, const WR2 &b) |
| R2 | operator+ (const R2 &a, const R2 &b) |
| SR2 | operator+ (const SR2 &a, const SR2 &b) |
| R3 | operator+ (const R3 &a, const R3 &b) |
| SFR3 | operator+ (const SFR3 &a, const SFR3 &b) |
| R4 | operator+ (const R4 &a, const R4 &b) |
| SFFR4 | operator+ (const SFFR4 &a, const SFFR4 &b) |
| WFFR4 | operator+ (const WFFR4 &a, const WFFR4 &b) |
| SSR4 | operator+ (const SSR4 &a, const SSR4 &b) |
| SWR4 | operator+ (const SWR4 &a, const SWR4 &b) |
| WSR4 | operator+ (const WSR4 &a, const WSR4 &b) |
| WWR4 | operator+ (const WWR4 &a, const WWR4 &b) |
| Quaternion | operator+ (const Quaternion &a, const Quaternion &b) |
| MillerIndex | operator+ (const MillerIndex &a, const MillerIndex &b) |
| Vec | operator+ (const Vec &a, const Scalar &b) |
| Vec | operator+ (const Scalar &a, const Vec &b) |
| Rot | operator+ (const Rot &a, const Scalar &b) |
| Rot | operator+ (const Scalar &a, const Rot &b) |
| WR2 | operator+ (const WR2 &a, const Scalar &b) |
| WR2 | operator+ (const Scalar &a, const WR2 &b) |
| R2 | operator+ (const R2 &a, const Scalar &b) |
| R2 | operator+ (const Scalar &a, const R2 &b) |
| SR2 | operator+ (const SR2 &a, const Scalar &b) |
| SR2 | operator+ (const Scalar &a, const SR2 &b) |
| R3 | operator+ (const R3 &a, const Scalar &b) |
| R3 | operator+ (const Scalar &a, const R3 &b) |
| SFR3 | operator+ (const SFR3 &a, const Scalar &b) |
| SFR3 | operator+ (const Scalar &a, const SFR3 &b) |
| R4 | operator+ (const R4 &a, const Scalar &b) |
| R4 | operator+ (const Scalar &a, const R4 &b) |
| SFFR4 | operator+ (const SFFR4 &a, const Scalar &b) |
| SFFR4 | operator+ (const Scalar &a, const SFFR4 &b) |
| WFFR4 | operator+ (const WFFR4 &a, const Scalar &b) |
| WFFR4 | operator+ (const Scalar &a, const WFFR4 &b) |
| SSR4 | operator+ (const SSR4 &a, const Scalar &b) |
| SSR4 | operator+ (const Scalar &a, const SSR4 &b) |
| SWR4 | operator+ (const SWR4 &a, const Scalar &b) |
| SWR4 | operator+ (const Scalar &a, const SWR4 &b) |
| WSR4 | operator+ (const WSR4 &a, const Scalar &b) |
| WSR4 | operator+ (const Scalar &a, const WSR4 &b) |
| WWR4 | operator+ (const WWR4 &a, const Scalar &b) |
| WWR4 | operator+ (const Scalar &a, const WWR4 &b) |
| Quaternion | operator+ (const Quaternion &a, const Scalar &b) |
| Quaternion | operator+ (const Scalar &a, const Quaternion &b) |
| MillerIndex | operator+ (const MillerIndex &a, const Scalar &b) |
| MillerIndex | operator+ (const Scalar &a, const MillerIndex &b) |
| Vec | operator+ (const Vec &a, const CScalar &b) |
| Vec | operator+ (const CScalar &a, const Vec &b) |
| Rot | operator+ (const Rot &a, const CScalar &b) |
| Rot | operator+ (const CScalar &a, const Rot &b) |
| WR2 | operator+ (const WR2 &a, const CScalar &b) |
| WR2 | operator+ (const CScalar &a, const WR2 &b) |
| R2 | operator+ (const R2 &a, const CScalar &b) |
| R2 | operator+ (const CScalar &a, const R2 &b) |
| SR2 | operator+ (const SR2 &a, const CScalar &b) |
| SR2 | operator+ (const CScalar &a, const SR2 &b) |
| R3 | operator+ (const R3 &a, const CScalar &b) |
| R3 | operator+ (const CScalar &a, const R3 &b) |
| SFR3 | operator+ (const SFR3 &a, const CScalar &b) |
| SFR3 | operator+ (const CScalar &a, const SFR3 &b) |
| R4 | operator+ (const R4 &a, const CScalar &b) |
| R4 | operator+ (const CScalar &a, const R4 &b) |
| SFFR4 | operator+ (const SFFR4 &a, const CScalar &b) |
| SFFR4 | operator+ (const CScalar &a, const SFFR4 &b) |
| WFFR4 | operator+ (const WFFR4 &a, const CScalar &b) |
| WFFR4 | operator+ (const CScalar &a, const WFFR4 &b) |
| SSR4 | operator+ (const SSR4 &a, const CScalar &b) |
| SSR4 | operator+ (const CScalar &a, const SSR4 &b) |
| SWR4 | operator+ (const SWR4 &a, const CScalar &b) |
| SWR4 | operator+ (const CScalar &a, const SWR4 &b) |
| WSR4 | operator+ (const WSR4 &a, const CScalar &b) |
| WSR4 | operator+ (const CScalar &a, const WSR4 &b) |
| WWR4 | operator+ (const WWR4 &a, const CScalar &b) |
| WWR4 | operator+ (const CScalar &a, const WWR4 &b) |
| Quaternion | operator+ (const Quaternion &a, const CScalar &b) |
| Quaternion | operator+ (const CScalar &a, const Quaternion &b) |
| MillerIndex | operator+ (const MillerIndex &a, const CScalar &b) |
| MillerIndex | operator+ (const CScalar &a, const MillerIndex &b) |
| Tensor | operator+ (const Tensor &a, const Tensor &b) |
| Tensor | operator+ (const Tensor &a, const Scalar &b) |
| Tensor | operator+ (const Scalar &a, const Tensor &b) |
| Tensor | operator+ (const Tensor &a, const CScalar &b) |
| Tensor | operator+ (const CScalar &a, const Tensor &b) |
| Scalar | operator+ (const Scalar &a, const Scalar &b) |
| Scalar | operator+ (const Scalar &a, const CScalar &b) |
| Scalar | operator+ (const CScalar &a, const Scalar &b) |
| Vec | operator- (const Vec &a, const Vec &b) |
| Rot | operator- (const Rot &a, const Rot &b) |
| WR2 | operator- (const WR2 &a, const WR2 &b) |
| R2 | operator- (const R2 &a, const R2 &b) |
| SR2 | operator- (const SR2 &a, const SR2 &b) |
| R3 | operator- (const R3 &a, const R3 &b) |
| SFR3 | operator- (const SFR3 &a, const SFR3 &b) |
| R4 | operator- (const R4 &a, const R4 &b) |
| SFFR4 | operator- (const SFFR4 &a, const SFFR4 &b) |
| WFFR4 | operator- (const WFFR4 &a, const WFFR4 &b) |
| SSR4 | operator- (const SSR4 &a, const SSR4 &b) |
| SWR4 | operator- (const SWR4 &a, const SWR4 &b) |
| WSR4 | operator- (const WSR4 &a, const WSR4 &b) |
| WWR4 | operator- (const WWR4 &a, const WWR4 &b) |
| Quaternion | operator- (const Quaternion &a, const Quaternion &b) |
| MillerIndex | operator- (const MillerIndex &a, const MillerIndex &b) |
| Vec | operator- (const Vec &a, const Scalar &b) |
| Vec | operator- (const Scalar &a, const Vec &b) |
| Rot | operator- (const Rot &a, const Scalar &b) |
| Rot | operator- (const Scalar &a, const Rot &b) |
| WR2 | operator- (const WR2 &a, const Scalar &b) |
| WR2 | operator- (const Scalar &a, const WR2 &b) |
| R2 | operator- (const R2 &a, const Scalar &b) |
| R2 | operator- (const Scalar &a, const R2 &b) |
| SR2 | operator- (const SR2 &a, const Scalar &b) |
| SR2 | operator- (const Scalar &a, const SR2 &b) |
| R3 | operator- (const R3 &a, const Scalar &b) |
| R3 | operator- (const Scalar &a, const R3 &b) |
| SFR3 | operator- (const SFR3 &a, const Scalar &b) |
| SFR3 | operator- (const Scalar &a, const SFR3 &b) |
| R4 | operator- (const R4 &a, const Scalar &b) |
| R4 | operator- (const Scalar &a, const R4 &b) |
| SFFR4 | operator- (const SFFR4 &a, const Scalar &b) |
| SFFR4 | operator- (const Scalar &a, const SFFR4 &b) |
| WFFR4 | operator- (const WFFR4 &a, const Scalar &b) |
| WFFR4 | operator- (const Scalar &a, const WFFR4 &b) |
| SSR4 | operator- (const SSR4 &a, const Scalar &b) |
| SSR4 | operator- (const Scalar &a, const SSR4 &b) |
| SWR4 | operator- (const SWR4 &a, const Scalar &b) |
| SWR4 | operator- (const Scalar &a, const SWR4 &b) |
| WSR4 | operator- (const WSR4 &a, const Scalar &b) |
| WSR4 | operator- (const Scalar &a, const WSR4 &b) |
| WWR4 | operator- (const WWR4 &a, const Scalar &b) |
| WWR4 | operator- (const Scalar &a, const WWR4 &b) |
| Quaternion | operator- (const Quaternion &a, const Scalar &b) |
| Quaternion | operator- (const Scalar &a, const Quaternion &b) |
| MillerIndex | operator- (const MillerIndex &a, const Scalar &b) |
| MillerIndex | operator- (const Scalar &a, const MillerIndex &b) |
| Vec | operator- (const Vec &a, const CScalar &b) |
| Vec | operator- (const CScalar &a, const Vec &b) |
| Rot | operator- (const Rot &a, const CScalar &b) |
| Rot | operator- (const CScalar &a, const Rot &b) |
| WR2 | operator- (const WR2 &a, const CScalar &b) |
| WR2 | operator- (const CScalar &a, const WR2 &b) |
| R2 | operator- (const R2 &a, const CScalar &b) |
| R2 | operator- (const CScalar &a, const R2 &b) |
| SR2 | operator- (const SR2 &a, const CScalar &b) |
| SR2 | operator- (const CScalar &a, const SR2 &b) |
| R3 | operator- (const R3 &a, const CScalar &b) |
| R3 | operator- (const CScalar &a, const R3 &b) |
| SFR3 | operator- (const SFR3 &a, const CScalar &b) |
| SFR3 | operator- (const CScalar &a, const SFR3 &b) |
| R4 | operator- (const R4 &a, const CScalar &b) |
| R4 | operator- (const CScalar &a, const R4 &b) |
| SFFR4 | operator- (const SFFR4 &a, const CScalar &b) |
| SFFR4 | operator- (const CScalar &a, const SFFR4 &b) |
| WFFR4 | operator- (const WFFR4 &a, const CScalar &b) |
| WFFR4 | operator- (const CScalar &a, const WFFR4 &b) |
| SSR4 | operator- (const SSR4 &a, const CScalar &b) |
| SSR4 | operator- (const CScalar &a, const SSR4 &b) |
| SWR4 | operator- (const SWR4 &a, const CScalar &b) |
| SWR4 | operator- (const CScalar &a, const SWR4 &b) |
| WSR4 | operator- (const WSR4 &a, const CScalar &b) |
| WSR4 | operator- (const CScalar &a, const WSR4 &b) |
| WWR4 | operator- (const WWR4 &a, const CScalar &b) |
| WWR4 | operator- (const CScalar &a, const WWR4 &b) |
| Quaternion | operator- (const Quaternion &a, const CScalar &b) |
| Quaternion | operator- (const CScalar &a, const Quaternion &b) |
| MillerIndex | operator- (const MillerIndex &a, const CScalar &b) |
| MillerIndex | operator- (const CScalar &a, const MillerIndex &b) |
| Tensor | operator- (const Tensor &a, const Tensor &b) |
| Tensor | operator- (const Tensor &a, const Scalar &b) |
| Tensor | operator- (const Scalar &a, const Tensor &b) |
| Tensor | operator- (const Tensor &a, const CScalar &b) |
| Tensor | operator- (const CScalar &a, const Tensor &b) |
| Scalar | operator- (const Scalar &a, const Scalar &b) |
| Scalar | operator- (const Scalar &a, const CScalar &b) |
| Scalar | operator- (const CScalar &a, const Scalar &b) |
| Vec | operator* (const Vec &a, const Scalar &b) |
| Vec | operator* (const Scalar &a, const Vec &b) |
| Rot | operator* (const Rot &a, const Scalar &b) |
| Rot | operator* (const Scalar &a, const Rot &b) |
| WR2 | operator* (const WR2 &a, const Scalar &b) |
| WR2 | operator* (const Scalar &a, const WR2 &b) |
| R2 | operator* (const R2 &a, const Scalar &b) |
| R2 | operator* (const Scalar &a, const R2 &b) |
| SR2 | operator* (const SR2 &a, const Scalar &b) |
| SR2 | operator* (const Scalar &a, const SR2 &b) |
| R3 | operator* (const R3 &a, const Scalar &b) |
| R3 | operator* (const Scalar &a, const R3 &b) |
| SFR3 | operator* (const SFR3 &a, const Scalar &b) |
| SFR3 | operator* (const Scalar &a, const SFR3 &b) |
| R4 | operator* (const R4 &a, const Scalar &b) |
| R4 | operator* (const Scalar &a, const R4 &b) |
| SFFR4 | operator* (const SFFR4 &a, const Scalar &b) |
| SFFR4 | operator* (const Scalar &a, const SFFR4 &b) |
| WFFR4 | operator* (const WFFR4 &a, const Scalar &b) |
| WFFR4 | operator* (const Scalar &a, const WFFR4 &b) |
| SSR4 | operator* (const SSR4 &a, const Scalar &b) |
| SSR4 | operator* (const Scalar &a, const SSR4 &b) |
| SWR4 | operator* (const SWR4 &a, const Scalar &b) |
| SWR4 | operator* (const Scalar &a, const SWR4 &b) |
| WSR4 | operator* (const WSR4 &a, const Scalar &b) |
| WSR4 | operator* (const Scalar &a, const WSR4 &b) |
| WWR4 | operator* (const WWR4 &a, const Scalar &b) |
| WWR4 | operator* (const Scalar &a, const WWR4 &b) |
| Quaternion | operator* (const Quaternion &a, const Scalar &b) |
| Quaternion | operator* (const Scalar &a, const Quaternion &b) |
| MillerIndex | operator* (const MillerIndex &a, const Scalar &b) |
| MillerIndex | operator* (const Scalar &a, const MillerIndex &b) |
| Vec | operator* (const Vec &a, const CScalar &b) |
| Vec | operator* (const CScalar &a, const Vec &b) |
| Rot | operator* (const Rot &a, const CScalar &b) |
| Rot | operator* (const CScalar &a, const Rot &b) |
| WR2 | operator* (const WR2 &a, const CScalar &b) |
| WR2 | operator* (const CScalar &a, const WR2 &b) |
| R2 | operator* (const R2 &a, const CScalar &b) |
| R2 | operator* (const CScalar &a, const R2 &b) |
| SR2 | operator* (const SR2 &a, const CScalar &b) |
| SR2 | operator* (const CScalar &a, const SR2 &b) |
| R3 | operator* (const R3 &a, const CScalar &b) |
| R3 | operator* (const CScalar &a, const R3 &b) |
| SFR3 | operator* (const SFR3 &a, const CScalar &b) |
| SFR3 | operator* (const CScalar &a, const SFR3 &b) |
| R4 | operator* (const R4 &a, const CScalar &b) |
| R4 | operator* (const CScalar &a, const R4 &b) |
| SFFR4 | operator* (const SFFR4 &a, const CScalar &b) |
| SFFR4 | operator* (const CScalar &a, const SFFR4 &b) |
| WFFR4 | operator* (const WFFR4 &a, const CScalar &b) |
| WFFR4 | operator* (const CScalar &a, const WFFR4 &b) |
| SSR4 | operator* (const SSR4 &a, const CScalar &b) |
| SSR4 | operator* (const CScalar &a, const SSR4 &b) |
| SWR4 | operator* (const SWR4 &a, const CScalar &b) |
| SWR4 | operator* (const CScalar &a, const SWR4 &b) |
| WSR4 | operator* (const WSR4 &a, const CScalar &b) |
| WSR4 | operator* (const CScalar &a, const WSR4 &b) |
| WWR4 | operator* (const WWR4 &a, const CScalar &b) |
| WWR4 | operator* (const CScalar &a, const WWR4 &b) |
| Quaternion | operator* (const Quaternion &a, const CScalar &b) |
| Quaternion | operator* (const CScalar &a, const Quaternion &b) |
| MillerIndex | operator* (const MillerIndex &a, const CScalar &b) |
| MillerIndex | operator* (const CScalar &a, const MillerIndex &b) |
| Tensor | operator* (const Tensor &a, const Tensor &b) |
| Tensor | operator* (const Tensor &a, const Scalar &b) |
| Tensor | operator* (const Scalar &a, const Tensor &b) |
| Tensor | operator* (const Tensor &a, const CScalar &b) |
| Tensor | operator* (const CScalar &a, const Tensor &b) |
| Scalar | operator* (const Scalar &a, const Scalar &b) |
| Scalar | operator* (const Scalar &a, const CScalar &b) |
| Scalar | operator* (const CScalar &a, const Scalar &b) |
| Vec | operator/ (const Vec &a, const Scalar &b) |
| Vec | operator/ (const Scalar &a, const Vec &b) |
| Rot | operator/ (const Rot &a, const Scalar &b) |
| Rot | operator/ (const Scalar &a, const Rot &b) |
| WR2 | operator/ (const WR2 &a, const Scalar &b) |
| WR2 | operator/ (const Scalar &a, const WR2 &b) |
| R2 | operator/ (const R2 &a, const Scalar &b) |
| R2 | operator/ (const Scalar &a, const R2 &b) |
| SR2 | operator/ (const SR2 &a, const Scalar &b) |
| SR2 | operator/ (const Scalar &a, const SR2 &b) |
| R3 | operator/ (const R3 &a, const Scalar &b) |
| R3 | operator/ (const Scalar &a, const R3 &b) |
| SFR3 | operator/ (const SFR3 &a, const Scalar &b) |
| SFR3 | operator/ (const Scalar &a, const SFR3 &b) |
| R4 | operator/ (const R4 &a, const Scalar &b) |
| R4 | operator/ (const Scalar &a, const R4 &b) |
| SFFR4 | operator/ (const SFFR4 &a, const Scalar &b) |
| SFFR4 | operator/ (const Scalar &a, const SFFR4 &b) |
| WFFR4 | operator/ (const WFFR4 &a, const Scalar &b) |
| WFFR4 | operator/ (const Scalar &a, const WFFR4 &b) |
| SSR4 | operator/ (const SSR4 &a, const Scalar &b) |
| SSR4 | operator/ (const Scalar &a, const SSR4 &b) |
| SWR4 | operator/ (const SWR4 &a, const Scalar &b) |
| SWR4 | operator/ (const Scalar &a, const SWR4 &b) |
| WSR4 | operator/ (const WSR4 &a, const Scalar &b) |
| WSR4 | operator/ (const Scalar &a, const WSR4 &b) |
| WWR4 | operator/ (const WWR4 &a, const Scalar &b) |
| WWR4 | operator/ (const Scalar &a, const WWR4 &b) |
| Quaternion | operator/ (const Quaternion &a, const Scalar &b) |
| Quaternion | operator/ (const Scalar &a, const Quaternion &b) |
| MillerIndex | operator/ (const MillerIndex &a, const Scalar &b) |
| MillerIndex | operator/ (const Scalar &a, const MillerIndex &b) |
| Vec | operator/ (const Vec &a, const CScalar &b) |
| Vec | operator/ (const CScalar &a, const Vec &b) |
| Rot | operator/ (const Rot &a, const CScalar &b) |
| Rot | operator/ (const CScalar &a, const Rot &b) |
| WR2 | operator/ (const WR2 &a, const CScalar &b) |
| WR2 | operator/ (const CScalar &a, const WR2 &b) |
| R2 | operator/ (const R2 &a, const CScalar &b) |
| R2 | operator/ (const CScalar &a, const R2 &b) |
| SR2 | operator/ (const SR2 &a, const CScalar &b) |
| SR2 | operator/ (const CScalar &a, const SR2 &b) |
| R3 | operator/ (const R3 &a, const CScalar &b) |
| R3 | operator/ (const CScalar &a, const R3 &b) |
| SFR3 | operator/ (const SFR3 &a, const CScalar &b) |
| SFR3 | operator/ (const CScalar &a, const SFR3 &b) |
| R4 | operator/ (const R4 &a, const CScalar &b) |
| R4 | operator/ (const CScalar &a, const R4 &b) |
| SFFR4 | operator/ (const SFFR4 &a, const CScalar &b) |
| SFFR4 | operator/ (const CScalar &a, const SFFR4 &b) |
| WFFR4 | operator/ (const WFFR4 &a, const CScalar &b) |
| WFFR4 | operator/ (const CScalar &a, const WFFR4 &b) |
| SSR4 | operator/ (const SSR4 &a, const CScalar &b) |
| SSR4 | operator/ (const CScalar &a, const SSR4 &b) |
| SWR4 | operator/ (const SWR4 &a, const CScalar &b) |
| SWR4 | operator/ (const CScalar &a, const SWR4 &b) |
| WSR4 | operator/ (const WSR4 &a, const CScalar &b) |
| WSR4 | operator/ (const CScalar &a, const WSR4 &b) |
| WWR4 | operator/ (const WWR4 &a, const CScalar &b) |
| WWR4 | operator/ (const CScalar &a, const WWR4 &b) |
| Quaternion | operator/ (const Quaternion &a, const CScalar &b) |
| Quaternion | operator/ (const CScalar &a, const Quaternion &b) |
| MillerIndex | operator/ (const MillerIndex &a, const CScalar &b) |
| MillerIndex | operator/ (const CScalar &a, const MillerIndex &b) |
| Tensor | operator/ (const Tensor &a, const Tensor &b) |
| Tensor | operator/ (const Tensor &a, const Scalar &b) |
| Tensor | operator/ (const Scalar &a, const Tensor &b) |
| Tensor | operator/ (const Tensor &a, const CScalar &b) |
| Tensor | operator/ (const CScalar &a, const Tensor &b) |
| Scalar | operator/ (const Scalar &a, const Scalar &b) |
| Scalar | operator/ (const Scalar &a, const CScalar &b) |
| Scalar | operator/ (const CScalar &a, const Scalar &b) |
| Vec & | operator+= (Vec &a, const CScalar &b) |
| Rot & | operator+= (Rot &a, const CScalar &b) |
| WR2 & | operator+= (WR2 &a, const CScalar &b) |
| R2 & | operator+= (R2 &a, const CScalar &b) |
| SR2 & | operator+= (SR2 &a, const CScalar &b) |
| R3 & | operator+= (R3 &a, const CScalar &b) |
| SFR3 & | operator+= (SFR3 &a, const CScalar &b) |
| R4 & | operator+= (R4 &a, const CScalar &b) |
| SFFR4 & | operator+= (SFFR4 &a, const CScalar &b) |
| WFFR4 & | operator+= (WFFR4 &a, const CScalar &b) |
| SSR4 & | operator+= (SSR4 &a, const CScalar &b) |
| SWR4 & | operator+= (SWR4 &a, const CScalar &b) |
| WSR4 & | operator+= (WSR4 &a, const CScalar &b) |
| WWR4 & | operator+= (WWR4 &a, const CScalar &b) |
| Quaternion & | operator+= (Quaternion &a, const CScalar &b) |
| MillerIndex & | operator+= (MillerIndex &a, const CScalar &b) |
| Tensor & | operator+= (Tensor &a, const CScalar &b) |
| Scalar & | operator+= (Scalar &a, const CScalar &b) |
| Vec & | operator-= (Vec &a, const CScalar &b) |
| Rot & | operator-= (Rot &a, const CScalar &b) |
| WR2 & | operator-= (WR2 &a, const CScalar &b) |
| R2 & | operator-= (R2 &a, const CScalar &b) |
| SR2 & | operator-= (SR2 &a, const CScalar &b) |
| R3 & | operator-= (R3 &a, const CScalar &b) |
| SFR3 & | operator-= (SFR3 &a, const CScalar &b) |
| R4 & | operator-= (R4 &a, const CScalar &b) |
| SFFR4 & | operator-= (SFFR4 &a, const CScalar &b) |
| WFFR4 & | operator-= (WFFR4 &a, const CScalar &b) |
| SSR4 & | operator-= (SSR4 &a, const CScalar &b) |
| SWR4 & | operator-= (SWR4 &a, const CScalar &b) |
| WSR4 & | operator-= (WSR4 &a, const CScalar &b) |
| WWR4 & | operator-= (WWR4 &a, const CScalar &b) |
| Quaternion & | operator-= (Quaternion &a, const CScalar &b) |
| MillerIndex & | operator-= (MillerIndex &a, const CScalar &b) |
| Tensor & | operator-= (Tensor &a, const CScalar &b) |
| Scalar & | operator-= (Scalar &a, const CScalar &b) |
| Vec & | operator*= (Vec &a, const CScalar &b) |
| Rot & | operator*= (Rot &a, const CScalar &b) |
| WR2 & | operator*= (WR2 &a, const CScalar &b) |
| R2 & | operator*= (R2 &a, const CScalar &b) |
| SR2 & | operator*= (SR2 &a, const CScalar &b) |
| R3 & | operator*= (R3 &a, const CScalar &b) |
| SFR3 & | operator*= (SFR3 &a, const CScalar &b) |
| R4 & | operator*= (R4 &a, const CScalar &b) |
| SFFR4 & | operator*= (SFFR4 &a, const CScalar &b) |
| WFFR4 & | operator*= (WFFR4 &a, const CScalar &b) |
| SSR4 & | operator*= (SSR4 &a, const CScalar &b) |
| SWR4 & | operator*= (SWR4 &a, const CScalar &b) |
| WSR4 & | operator*= (WSR4 &a, const CScalar &b) |
| WWR4 & | operator*= (WWR4 &a, const CScalar &b) |
| Quaternion & | operator*= (Quaternion &a, const CScalar &b) |
| MillerIndex & | operator*= (MillerIndex &a, const CScalar &b) |
| Tensor & | operator*= (Tensor &a, const CScalar &b) |
| Scalar & | operator*= (Scalar &a, const CScalar &b) |
| Vec & | operator/= (Vec &a, const CScalar &b) |
| Rot & | operator/= (Rot &a, const CScalar &b) |
| WR2 & | operator/= (WR2 &a, const CScalar &b) |
| R2 & | operator/= (R2 &a, const CScalar &b) |
| SR2 & | operator/= (SR2 &a, const CScalar &b) |
| R3 & | operator/= (R3 &a, const CScalar &b) |
| SFR3 & | operator/= (SFR3 &a, const CScalar &b) |
| R4 & | operator/= (R4 &a, const CScalar &b) |
| SFFR4 & | operator/= (SFFR4 &a, const CScalar &b) |
| WFFR4 & | operator/= (WFFR4 &a, const CScalar &b) |
| SSR4 & | operator/= (SSR4 &a, const CScalar &b) |
| SWR4 & | operator/= (SWR4 &a, const CScalar &b) |
| WSR4 & | operator/= (WSR4 &a, const CScalar &b) |
| WWR4 & | operator/= (WWR4 &a, const CScalar &b) |
| Quaternion & | operator/= (Quaternion &a, const CScalar &b) |
| MillerIndex & | operator/= (MillerIndex &a, const CScalar &b) |
| Tensor & | operator/= (Tensor &a, const CScalar &b) |
| Scalar & | operator/= (Scalar &a, const CScalar &b) |
| Vec | pow (const Vec &a, const CScalar &n) |
| Vec | pow (const Vec &a, const Scalar &n) |
| Rot | pow (const Rot &a, const CScalar &n) |
| Rot | pow (const Rot &a, const Scalar &n) |
| WR2 | pow (const WR2 &a, const CScalar &n) |
| WR2 | pow (const WR2 &a, const Scalar &n) |
| R2 | pow (const R2 &a, const CScalar &n) |
| R2 | pow (const R2 &a, const Scalar &n) |
| SR2 | pow (const SR2 &a, const CScalar &n) |
| SR2 | pow (const SR2 &a, const Scalar &n) |
| R3 | pow (const R3 &a, const CScalar &n) |
| R3 | pow (const R3 &a, const Scalar &n) |
| SFR3 | pow (const SFR3 &a, const CScalar &n) |
| SFR3 | pow (const SFR3 &a, const Scalar &n) |
| R4 | pow (const R4 &a, const CScalar &n) |
| R4 | pow (const R4 &a, const Scalar &n) |
| SFFR4 | pow (const SFFR4 &a, const CScalar &n) |
| SFFR4 | pow (const SFFR4 &a, const Scalar &n) |
| WFFR4 | pow (const WFFR4 &a, const CScalar &n) |
| WFFR4 | pow (const WFFR4 &a, const Scalar &n) |
| SSR4 | pow (const SSR4 &a, const CScalar &n) |
| SSR4 | pow (const SSR4 &a, const Scalar &n) |
| SWR4 | pow (const SWR4 &a, const CScalar &n) |
| SWR4 | pow (const SWR4 &a, const Scalar &n) |
| WSR4 | pow (const WSR4 &a, const CScalar &n) |
| WSR4 | pow (const WSR4 &a, const Scalar &n) |
| WWR4 | pow (const WWR4 &a, const CScalar &n) |
| WWR4 | pow (const WWR4 &a, const Scalar &n) |
| Quaternion | pow (const Quaternion &a, const CScalar &n) |
| Quaternion | pow (const Quaternion &a, const Scalar &n) |
| MillerIndex | pow (const MillerIndex &a, const CScalar &n) |
| MillerIndex | pow (const MillerIndex &a, const Scalar &n) |
| Tensor | pow (const Tensor &a, const CScalar &n) |
| Tensor | pow (const Tensor &a, const Scalar &n) |
| Scalar | pow (const Scalar &a, const CScalar &n) |
| Scalar | pow (const Scalar &a, const Scalar &n) |
| Scalar | pow (const CScalar &a, const Scalar &n) |
| Tensor | pow (const Tensor &a, const Tensor &n) |
| | Element-wise pow.
|
| Tensor | pow (const CScalar &a, const Tensor &n) |
| | Element-wise pow.
|
| Vec | sign (const Vec &a) |
| Rot | sign (const Rot &a) |
| WR2 | sign (const WR2 &a) |
| R2 | sign (const R2 &a) |
| SR2 | sign (const SR2 &a) |
| R3 | sign (const R3 &a) |
| SFR3 | sign (const SFR3 &a) |
| R4 | sign (const R4 &a) |
| SFFR4 | sign (const SFFR4 &a) |
| WFFR4 | sign (const WFFR4 &a) |
| SSR4 | sign (const SSR4 &a) |
| SWR4 | sign (const SWR4 &a) |
| WSR4 | sign (const WSR4 &a) |
| WWR4 | sign (const WWR4 &a) |
| Quaternion | sign (const Quaternion &a) |
| MillerIndex | sign (const MillerIndex &a) |
| Tensor | sign (const Tensor &a) |
| Scalar | sign (const Scalar &a) |
| Vec | sin (const Vec &a) |
| Rot | sin (const Rot &a) |
| WR2 | sin (const WR2 &a) |
| R2 | sin (const R2 &a) |
| SR2 | sin (const SR2 &a) |
| R3 | sin (const R3 &a) |
| SFR3 | sin (const SFR3 &a) |
| R4 | sin (const R4 &a) |
| SFFR4 | sin (const SFFR4 &a) |
| WFFR4 | sin (const WFFR4 &a) |
| SSR4 | sin (const SSR4 &a) |
| SWR4 | sin (const SWR4 &a) |
| WSR4 | sin (const WSR4 &a) |
| WWR4 | sin (const WWR4 &a) |
| Quaternion | sin (const Quaternion &a) |
| MillerIndex | sin (const MillerIndex &a) |
| Tensor | sin (const Tensor &a) |
| Scalar | sin (const Scalar &a) |
| Vec | sinh (const Vec &a) |
| Rot | sinh (const Rot &a) |
| WR2 | sinh (const WR2 &a) |
| R2 | sinh (const R2 &a) |
| SR2 | sinh (const SR2 &a) |
| R3 | sinh (const R3 &a) |
| SFR3 | sinh (const SFR3 &a) |
| R4 | sinh (const R4 &a) |
| SFFR4 | sinh (const SFFR4 &a) |
| WFFR4 | sinh (const WFFR4 &a) |
| SSR4 | sinh (const SSR4 &a) |
| SWR4 | sinh (const SWR4 &a) |
| WSR4 | sinh (const WSR4 &a) |
| WWR4 | sinh (const WWR4 &a) |
| Quaternion | sinh (const Quaternion &a) |
| MillerIndex | sinh (const MillerIndex &a) |
| Tensor | sinh (const Tensor &a) |
| Scalar | sinh (const Scalar &a) |
| Vec | sqrt (const Vec &a) |
| Rot | sqrt (const Rot &a) |
| WR2 | sqrt (const WR2 &a) |
| R2 | sqrt (const R2 &a) |
| SR2 | sqrt (const SR2 &a) |
| R3 | sqrt (const R3 &a) |
| SFR3 | sqrt (const SFR3 &a) |
| R4 | sqrt (const R4 &a) |
| SFFR4 | sqrt (const SFFR4 &a) |
| WFFR4 | sqrt (const WFFR4 &a) |
| SSR4 | sqrt (const SSR4 &a) |
| SWR4 | sqrt (const SWR4 &a) |
| WSR4 | sqrt (const WSR4 &a) |
| WWR4 | sqrt (const WWR4 &a) |
| Quaternion | sqrt (const Quaternion &a) |
| MillerIndex | sqrt (const MillerIndex &a) |
| Tensor | sqrt (const Tensor &a) |
| Scalar | sqrt (const Scalar &a) |
| Vec | dynamic_stack (const std::vector< Vec > &tensors, Size d=0) |
| Vec | dynamic_stack (const std::initializer_list< Vec > &tensors, Size d=0) |
| Vec | intmd_stack (const std::vector< Vec > &tensors, Size d=0) |
| Vec | intmd_stack (const std::initializer_list< Vec > &tensors, Size d=0) |
| Rot | dynamic_stack (const std::vector< Rot > &tensors, Size d=0) |
| Rot | dynamic_stack (const std::initializer_list< Rot > &tensors, Size d=0) |
| Rot | intmd_stack (const std::vector< Rot > &tensors, Size d=0) |
| Rot | intmd_stack (const std::initializer_list< Rot > &tensors, Size d=0) |
| WR2 | dynamic_stack (const std::vector< WR2 > &tensors, Size d=0) |
| WR2 | dynamic_stack (const std::initializer_list< WR2 > &tensors, Size d=0) |
| WR2 | intmd_stack (const std::vector< WR2 > &tensors, Size d=0) |
| WR2 | intmd_stack (const std::initializer_list< WR2 > &tensors, Size d=0) |
| R2 | dynamic_stack (const std::vector< R2 > &tensors, Size d=0) |
| R2 | dynamic_stack (const std::initializer_list< R2 > &tensors, Size d=0) |
| R2 | intmd_stack (const std::vector< R2 > &tensors, Size d=0) |
| R2 | intmd_stack (const std::initializer_list< R2 > &tensors, Size d=0) |
| SR2 | dynamic_stack (const std::vector< SR2 > &tensors, Size d=0) |
| SR2 | dynamic_stack (const std::initializer_list< SR2 > &tensors, Size d=0) |
| SR2 | intmd_stack (const std::vector< SR2 > &tensors, Size d=0) |
| SR2 | intmd_stack (const std::initializer_list< SR2 > &tensors, Size d=0) |
| R3 | dynamic_stack (const std::vector< R3 > &tensors, Size d=0) |
| R3 | dynamic_stack (const std::initializer_list< R3 > &tensors, Size d=0) |
| R3 | intmd_stack (const std::vector< R3 > &tensors, Size d=0) |
| R3 | intmd_stack (const std::initializer_list< R3 > &tensors, Size d=0) |
| SFR3 | dynamic_stack (const std::vector< SFR3 > &tensors, Size d=0) |
| SFR3 | dynamic_stack (const std::initializer_list< SFR3 > &tensors, Size d=0) |
| SFR3 | intmd_stack (const std::vector< SFR3 > &tensors, Size d=0) |
| SFR3 | intmd_stack (const std::initializer_list< SFR3 > &tensors, Size d=0) |
| R4 | dynamic_stack (const std::vector< R4 > &tensors, Size d=0) |
| R4 | dynamic_stack (const std::initializer_list< R4 > &tensors, Size d=0) |
| R4 | intmd_stack (const std::vector< R4 > &tensors, Size d=0) |
| R4 | intmd_stack (const std::initializer_list< R4 > &tensors, Size d=0) |
| SFFR4 | dynamic_stack (const std::vector< SFFR4 > &tensors, Size d=0) |
| SFFR4 | dynamic_stack (const std::initializer_list< SFFR4 > &tensors, Size d=0) |
| SFFR4 | intmd_stack (const std::vector< SFFR4 > &tensors, Size d=0) |
| SFFR4 | intmd_stack (const std::initializer_list< SFFR4 > &tensors, Size d=0) |
| WFFR4 | dynamic_stack (const std::vector< WFFR4 > &tensors, Size d=0) |
| WFFR4 | dynamic_stack (const std::initializer_list< WFFR4 > &tensors, Size d=0) |
| WFFR4 | intmd_stack (const std::vector< WFFR4 > &tensors, Size d=0) |
| WFFR4 | intmd_stack (const std::initializer_list< WFFR4 > &tensors, Size d=0) |
| SSR4 | dynamic_stack (const std::vector< SSR4 > &tensors, Size d=0) |
| SSR4 | dynamic_stack (const std::initializer_list< SSR4 > &tensors, Size d=0) |
| SSR4 | intmd_stack (const std::vector< SSR4 > &tensors, Size d=0) |
| SSR4 | intmd_stack (const std::initializer_list< SSR4 > &tensors, Size d=0) |
| SWR4 | dynamic_stack (const std::vector< SWR4 > &tensors, Size d=0) |
| SWR4 | dynamic_stack (const std::initializer_list< SWR4 > &tensors, Size d=0) |
| SWR4 | intmd_stack (const std::vector< SWR4 > &tensors, Size d=0) |
| SWR4 | intmd_stack (const std::initializer_list< SWR4 > &tensors, Size d=0) |
| WSR4 | dynamic_stack (const std::vector< WSR4 > &tensors, Size d=0) |
| WSR4 | dynamic_stack (const std::initializer_list< WSR4 > &tensors, Size d=0) |
| WSR4 | intmd_stack (const std::vector< WSR4 > &tensors, Size d=0) |
| WSR4 | intmd_stack (const std::initializer_list< WSR4 > &tensors, Size d=0) |
| WWR4 | dynamic_stack (const std::vector< WWR4 > &tensors, Size d=0) |
| WWR4 | dynamic_stack (const std::initializer_list< WWR4 > &tensors, Size d=0) |
| WWR4 | intmd_stack (const std::vector< WWR4 > &tensors, Size d=0) |
| WWR4 | intmd_stack (const std::initializer_list< WWR4 > &tensors, Size d=0) |
| Quaternion | dynamic_stack (const std::vector< Quaternion > &tensors, Size d=0) |
| Quaternion | dynamic_stack (const std::initializer_list< Quaternion > &tensors, Size d=0) |
| Quaternion | intmd_stack (const std::vector< Quaternion > &tensors, Size d=0) |
| Quaternion | intmd_stack (const std::initializer_list< Quaternion > &tensors, Size d=0) |
| MillerIndex | dynamic_stack (const std::vector< MillerIndex > &tensors, Size d=0) |
| MillerIndex | dynamic_stack (const std::initializer_list< MillerIndex > &tensors, Size d=0) |
| MillerIndex | intmd_stack (const std::vector< MillerIndex > &tensors, Size d=0) |
| MillerIndex | intmd_stack (const std::initializer_list< MillerIndex > &tensors, Size d=0) |
| Tensor | dynamic_stack (const std::vector< Tensor > &tensors, Size d=0) |
| Tensor | dynamic_stack (const std::initializer_list< Tensor > &tensors, Size d=0) |
| Tensor | intmd_stack (const std::vector< Tensor > &tensors, Size d=0) |
| Tensor | intmd_stack (const std::initializer_list< Tensor > &tensors, Size d=0) |
| Scalar | dynamic_stack (const std::vector< Scalar > &tensors, Size d=0) |
| Scalar | dynamic_stack (const std::initializer_list< Scalar > &tensors, Size d=0) |
| Scalar | intmd_stack (const std::vector< Scalar > &tensors, Size d=0) |
| Scalar | intmd_stack (const std::initializer_list< Scalar > &tensors, Size d=0) |
| neml2::Tensor | base_stack (const std::vector< Tensor > &tensors, Size d=0) |
| Vec | dynamic_sum (const Vec &a, ArrayRef< Size > d=0, bool keepdim=false) |
| Vec | intmd_sum (const Vec &a, ArrayRef< Size > d=0, bool keepdim=false) |
| Rot | dynamic_sum (const Rot &a, ArrayRef< Size > d=0, bool keepdim=false) |
| Rot | intmd_sum (const Rot &a, ArrayRef< Size > d=0, bool keepdim=false) |
| WR2 | dynamic_sum (const WR2 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| WR2 | intmd_sum (const WR2 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| R2 | dynamic_sum (const R2 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| R2 | intmd_sum (const R2 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| SR2 | dynamic_sum (const SR2 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| SR2 | intmd_sum (const SR2 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| R3 | dynamic_sum (const R3 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| R3 | intmd_sum (const R3 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| SFR3 | dynamic_sum (const SFR3 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| SFR3 | intmd_sum (const SFR3 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| R4 | dynamic_sum (const R4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| R4 | intmd_sum (const R4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| SFFR4 | dynamic_sum (const SFFR4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| SFFR4 | intmd_sum (const SFFR4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| WFFR4 | dynamic_sum (const WFFR4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| WFFR4 | intmd_sum (const WFFR4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| SSR4 | dynamic_sum (const SSR4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| SSR4 | intmd_sum (const SSR4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| SWR4 | dynamic_sum (const SWR4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| SWR4 | intmd_sum (const SWR4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| WSR4 | dynamic_sum (const WSR4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| WSR4 | intmd_sum (const WSR4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| WWR4 | dynamic_sum (const WWR4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| WWR4 | intmd_sum (const WWR4 &a, ArrayRef< Size > d=0, bool keepdim=false) |
| Quaternion | dynamic_sum (const Quaternion &a, ArrayRef< Size > d=0, bool keepdim=false) |
| Quaternion | intmd_sum (const Quaternion &a, ArrayRef< Size > d=0, bool keepdim=false) |
| MillerIndex | dynamic_sum (const MillerIndex &a, ArrayRef< Size > d=0, bool keepdim=false) |
| MillerIndex | intmd_sum (const MillerIndex &a, ArrayRef< Size > d=0, bool keepdim=false) |
| Tensor | dynamic_sum (const Tensor &a, ArrayRef< Size > d=0, bool keepdim=false) |
| Tensor | intmd_sum (const Tensor &a, ArrayRef< Size > d=0, bool keepdim=false) |
| Scalar | dynamic_sum (const Scalar &a, ArrayRef< Size > d=0, bool keepdim=false) |
| Scalar | intmd_sum (const Scalar &a, ArrayRef< Size > d=0, bool keepdim=false) |
| Tensor | base_sum (const Tensor &a, ArrayRef< Size > d=0, bool keepdim=false) |
| Vec | dynamic_sum_to_size (const Vec &a, const TraceableTensorShape &shape) |
| Vec | intmd_sum_to_size (const Vec &a, TensorShapeRef shape) |
| Rot | dynamic_sum_to_size (const Rot &a, const TraceableTensorShape &shape) |
| Rot | intmd_sum_to_size (const Rot &a, TensorShapeRef shape) |
| WR2 | dynamic_sum_to_size (const WR2 &a, const TraceableTensorShape &shape) |
| WR2 | intmd_sum_to_size (const WR2 &a, TensorShapeRef shape) |
| R2 | dynamic_sum_to_size (const R2 &a, const TraceableTensorShape &shape) |
| R2 | intmd_sum_to_size (const R2 &a, TensorShapeRef shape) |
| SR2 | dynamic_sum_to_size (const SR2 &a, const TraceableTensorShape &shape) |
| SR2 | intmd_sum_to_size (const SR2 &a, TensorShapeRef shape) |
| R3 | dynamic_sum_to_size (const R3 &a, const TraceableTensorShape &shape) |
| R3 | intmd_sum_to_size (const R3 &a, TensorShapeRef shape) |
| SFR3 | dynamic_sum_to_size (const SFR3 &a, const TraceableTensorShape &shape) |
| SFR3 | intmd_sum_to_size (const SFR3 &a, TensorShapeRef shape) |
| R4 | dynamic_sum_to_size (const R4 &a, const TraceableTensorShape &shape) |
| R4 | intmd_sum_to_size (const R4 &a, TensorShapeRef shape) |
| SFFR4 | dynamic_sum_to_size (const SFFR4 &a, const TraceableTensorShape &shape) |
| SFFR4 | intmd_sum_to_size (const SFFR4 &a, TensorShapeRef shape) |
| WFFR4 | dynamic_sum_to_size (const WFFR4 &a, const TraceableTensorShape &shape) |
| WFFR4 | intmd_sum_to_size (const WFFR4 &a, TensorShapeRef shape) |
| SSR4 | dynamic_sum_to_size (const SSR4 &a, const TraceableTensorShape &shape) |
| SSR4 | intmd_sum_to_size (const SSR4 &a, TensorShapeRef shape) |
| SWR4 | dynamic_sum_to_size (const SWR4 &a, const TraceableTensorShape &shape) |
| SWR4 | intmd_sum_to_size (const SWR4 &a, TensorShapeRef shape) |
| WSR4 | dynamic_sum_to_size (const WSR4 &a, const TraceableTensorShape &shape) |
| WSR4 | intmd_sum_to_size (const WSR4 &a, TensorShapeRef shape) |
| WWR4 | dynamic_sum_to_size (const WWR4 &a, const TraceableTensorShape &shape) |
| WWR4 | intmd_sum_to_size (const WWR4 &a, TensorShapeRef shape) |
| Quaternion | dynamic_sum_to_size (const Quaternion &a, const TraceableTensorShape &shape) |
| Quaternion | intmd_sum_to_size (const Quaternion &a, TensorShapeRef shape) |
| MillerIndex | dynamic_sum_to_size (const MillerIndex &a, const TraceableTensorShape &shape) |
| MillerIndex | intmd_sum_to_size (const MillerIndex &a, TensorShapeRef shape) |
| Tensor | dynamic_sum_to_size (const Tensor &a, const TraceableTensorShape &shape) |
| Tensor | intmd_sum_to_size (const Tensor &a, TensorShapeRef shape) |
| Scalar | dynamic_sum_to_size (const Scalar &a, const TraceableTensorShape &shape) |
| Scalar | intmd_sum_to_size (const Scalar &a, TensorShapeRef shape) |
| Tensor | base_sum_to_size (const Tensor &a, TensorShapeRef shape) |
| constexpr double | mandel_factor (Size i) |
| Tensor | full_to_mandel (const Tensor &full, Size dim=0) |
| | Convert a Tensor from full notation to Mandel notation.
|
| Tensor | mandel_to_full (const Tensor &mandel, Size dim=0) |
| | Convert a Tensor from Mandel notation to full notation.
|
| Tensor | full_to_skew (const Tensor &full, Size dim=0) |
| | Convert a Tensor from full notation to skew vector notation.
|
| Tensor | skew_to_full (const Tensor &skew, Size dim=0) |
| | Convert a Tensor from skew vector notation to full notation.
|
| Vec | tan (const Vec &a) |
| Rot | tan (const Rot &a) |
| WR2 | tan (const WR2 &a) |
| R2 | tan (const R2 &a) |
| SR2 | tan (const SR2 &a) |
| R3 | tan (const R3 &a) |
| SFR3 | tan (const SFR3 &a) |
| R4 | tan (const R4 &a) |
| SFFR4 | tan (const SFFR4 &a) |
| WFFR4 | tan (const WFFR4 &a) |
| SSR4 | tan (const SSR4 &a) |
| SWR4 | tan (const SWR4 &a) |
| WSR4 | tan (const WSR4 &a) |
| WWR4 | tan (const WWR4 &a) |
| Quaternion | tan (const Quaternion &a) |
| MillerIndex | tan (const MillerIndex &a) |
| Tensor | tan (const Tensor &a) |
| Scalar | tan (const Scalar &a) |
| Vec | tanh (const Vec &a) |
| Rot | tanh (const Rot &a) |
| WR2 | tanh (const WR2 &a) |
| R2 | tanh (const R2 &a) |
| SR2 | tanh (const SR2 &a) |
| R3 | tanh (const R3 &a) |
| SFR3 | tanh (const SFR3 &a) |
| R4 | tanh (const R4 &a) |
| SFFR4 | tanh (const SFFR4 &a) |
| WFFR4 | tanh (const WFFR4 &a) |
| SSR4 | tanh (const SSR4 &a) |
| SWR4 | tanh (const SWR4 &a) |
| WSR4 | tanh (const WSR4 &a) |
| WWR4 | tanh (const WWR4 &a) |
| Quaternion | tanh (const Quaternion &a) |
| MillerIndex | tanh (const MillerIndex &a) |
| Tensor | tanh (const Tensor &a) |
| Scalar | tanh (const Scalar &a) |
| Scalar | vdot (const Tensor &u, const Tensor &v) |
| | Vector-vector dot product.
|
| Vec | where (const Tensor &c, const Vec &a, const Vec &b) |
| Vec | where (const Scalar &c, const Vec &a, const Vec &b) |
| Rot | where (const Tensor &c, const Rot &a, const Rot &b) |
| Rot | where (const Scalar &c, const Rot &a, const Rot &b) |
| WR2 | where (const Tensor &c, const WR2 &a, const WR2 &b) |
| WR2 | where (const Scalar &c, const WR2 &a, const WR2 &b) |
| R2 | where (const Tensor &c, const R2 &a, const R2 &b) |
| R2 | where (const Scalar &c, const R2 &a, const R2 &b) |
| SR2 | where (const Tensor &c, const SR2 &a, const SR2 &b) |
| SR2 | where (const Scalar &c, const SR2 &a, const SR2 &b) |
| R3 | where (const Tensor &c, const R3 &a, const R3 &b) |
| R3 | where (const Scalar &c, const R3 &a, const R3 &b) |
| SFR3 | where (const Tensor &c, const SFR3 &a, const SFR3 &b) |
| SFR3 | where (const Scalar &c, const SFR3 &a, const SFR3 &b) |
| R4 | where (const Tensor &c, const R4 &a, const R4 &b) |
| R4 | where (const Scalar &c, const R4 &a, const R4 &b) |
| SFFR4 | where (const Tensor &c, const SFFR4 &a, const SFFR4 &b) |
| SFFR4 | where (const Scalar &c, const SFFR4 &a, const SFFR4 &b) |
| WFFR4 | where (const Tensor &c, const WFFR4 &a, const WFFR4 &b) |
| WFFR4 | where (const Scalar &c, const WFFR4 &a, const WFFR4 &b) |
| SSR4 | where (const Tensor &c, const SSR4 &a, const SSR4 &b) |
| SSR4 | where (const Scalar &c, const SSR4 &a, const SSR4 &b) |
| SWR4 | where (const Tensor &c, const SWR4 &a, const SWR4 &b) |
| SWR4 | where (const Scalar &c, const SWR4 &a, const SWR4 &b) |
| WSR4 | where (const Tensor &c, const WSR4 &a, const WSR4 &b) |
| WSR4 | where (const Scalar &c, const WSR4 &a, const WSR4 &b) |
| WWR4 | where (const Tensor &c, const WWR4 &a, const WWR4 &b) |
| WWR4 | where (const Scalar &c, const WWR4 &a, const WWR4 &b) |
| Quaternion | where (const Tensor &c, const Quaternion &a, const Quaternion &b) |
| Quaternion | where (const Scalar &c, const Quaternion &a, const Quaternion &b) |
| MillerIndex | where (const Tensor &c, const MillerIndex &a, const MillerIndex &b) |
| MillerIndex | where (const Scalar &c, const MillerIndex &a, const MillerIndex &b) |
| Tensor | where (const Tensor &c, const Tensor &a, const Tensor &b) |
| Tensor | where (const Scalar &c, const Tensor &a, const Tensor &b) |
| Scalar | where (const Tensor &c, const Scalar &a, const Scalar &b) |
| Scalar | where (const Scalar &c, const Scalar &a, const Scalar &b) |
| void | neml_assert_tracing () |
| | Assert that we are currently tracing.
|
| void | neml_assert_not_tracing () |
| | Assert that we are currently NOT tracing.
|
| void | neml_assert_tracing_dbg () |
| | Assert that we are currently tracing (only effective in debug mode).
|
| void | neml_assert_not_tracing_dbg () |
| | Assert that we are currently NOT tracing (only effective in debug mode).
|
| template<class Tuple, std::size_t... I> |
| auto | make_tensors (Tuple &&t, std::index_sequence< I... >, const TensorOptions &options) |
| R2 | operator* (const R2 &, const R2 &) |
| | matrix-matrix product
|
| Vec | operator* (const R2 &, const Vec &) |
| | matrix-vector product
|
| Rot | operator* (const Rot &r1, const Rot &r2) |
| | Composition of rotations r3 = r1 * r2 (r2 first, then r1).
|
| Vec | convert_euler_angles_from_kocks (const Vec &angles, const std::string &to_convention) |
| | Convert between Euler angle types.
|
| SSR4 | operator* (const SSR4 &a, const SSR4 &b) |
| SR2 | operator* (const SSR4 &a, const SR2 &b) |
| std::ostream & | operator<< (std::ostream &os, const TensorType &t) |
| std::ostream & | operator<< (std::ostream &os, const TraceableSize &s) |
| | Streaming operator.
|
| R2 | transform_from_quaternion (const Quaternion &q) |
| | Construct from quaternions, useful for comparison to old NEML.
|
| R2 | identity_transform (const TensorOptions &options=default_tensor_options()) |
| | The identity transformation, i.e.e the Rank2 identity tensor.
|
| R2 | proper_rotation_transform (const Rot &rot) |
| | A proper rotation, here provided by a Rot object.
|
| R2 | improper_rotation_transform (const Rot &rot) |
| | An improper rotation (rotation + reflection), here provided by a rot object giving the rotation and reflection axis.
|
| R2 | reflection_transform (const Vec &v) |
| | A reflection, defined by the reflection plane.
|
| R2 | inversion_transform (const TensorOptions &options=default_tensor_options()) |
| | An inversion center.
|
| SparseTensorList | operator- (const SparseTensorList &) |
| SparseTensorList | operator+ (const SparseTensorList &, const SparseTensorList &) |
| | Binary addition.
|
| SparseTensorList | operator* (const Scalar &, const SparseTensorList &) |
| | Multiplication with scalar.
|
| SparseTensorList | operator* (const SparseTensorList &, const Scalar &) |
| Scalar | inner (const SparseTensorList &, const SparseTensorList &) |
| | Inner product.
|
| Scalar | norm_sq (const SparseTensorList &) |
| | Norm-squared.
|
| Scalar | norm (const SparseTensorList &) |
| | Norm.
|
The factory methods like at::arange, at::ones, at::zeros, at::rand etc. accept a common argument to configure the properties of the tensor being created. We predefine a default tensor configuration in NEML2. This default configuration is consistently used throughout NEML2.
See https://pytorch.org/cppdocs/notes/tensor_creation.html#configuring-properties-of-the-tensor for more details.
|
| void | set_default_dtype (Dtype dtype) |
| Dtype | get_default_dtype () |
| | Get default dtype.
|
| TensorOptions | default_tensor_options () |
| | Default floating point tensor options.
|
| void | set_default_integer_dtype (Dtype dtype) |
| | Set default integer dtype.
|
| Dtype | get_default_integer_dtype () |
| | Get default integer dtype.
|
| TensorOptions | default_integer_tensor_options () |
| | Default integral tensor options.
|
| template<class... T> |
| void | neml_assert_broadcastable (const T &...) |
| template<class... T> |
| void | neml_assert_dynamic_broadcastable (const T &...) |
| template<class... T> |
| void | neml_assert_intmd_broadcastable (const T &...) |
| template<class... T> |
| void | neml_assert_batch_broadcastable (const T &...) |
| template<class... T> |
| void | neml_assert_base_broadcastable (const T &...) |
| template<class... T> |
| void | neml_assert_static_broadcastable (const T &...) |
| Scalar | det (const Tensor &) |
| Scalar | det (const R2 &) |
| Scalar | det (const SR2 &) |
| Scalar | det (const WR2 &) |
| Tensor | dev (const Tensor &) |
| R2 | dev (const R2 &) |
| SR2 | dev (const SR2 &) |
| WR2 | dev (const WR2 &) |
| R2 | inv (const R2 &) |
| SR2 | inv (const SR2 &) |
| R4 | inv (const R4 &) |
| SSR4 | inv (const SSR4 &) |
| Vec | dynamic_linspace (const Vec &start, const Vec &end, Size nstep, Size dim=0) |
| Vec | intmd_linspace (const Vec &start, const Vec &end, Size nstep, Size dim=0) |
| Rot | dynamic_linspace (const Rot &start, const Rot &end, Size nstep, Size dim=0) |
| Rot | intmd_linspace (const Rot &start, const Rot &end, Size nstep, Size dim=0) |
| WR2 | dynamic_linspace (const WR2 &start, const WR2 &end, Size nstep, Size dim=0) |
| WR2 | intmd_linspace (const WR2 &start, const WR2 &end, Size nstep, Size dim=0) |
| R2 | dynamic_linspace (const R2 &start, const R2 &end, Size nstep, Size dim=0) |
| R2 | intmd_linspace (const R2 &start, const R2 &end, Size nstep, Size dim=0) |
| SR2 | dynamic_linspace (const SR2 &start, const SR2 &end, Size nstep, Size dim=0) |
| SR2 | intmd_linspace (const SR2 &start, const SR2 &end, Size nstep, Size dim=0) |
| R3 | dynamic_linspace (const R3 &start, const R3 &end, Size nstep, Size dim=0) |
| R3 | intmd_linspace (const R3 &start, const R3 &end, Size nstep, Size dim=0) |
| SFR3 | dynamic_linspace (const SFR3 &start, const SFR3 &end, Size nstep, Size dim=0) |
| SFR3 | intmd_linspace (const SFR3 &start, const SFR3 &end, Size nstep, Size dim=0) |
| R4 | dynamic_linspace (const R4 &start, const R4 &end, Size nstep, Size dim=0) |
| R4 | intmd_linspace (const R4 &start, const R4 &end, Size nstep, Size dim=0) |
| SFFR4 | dynamic_linspace (const SFFR4 &start, const SFFR4 &end, Size nstep, Size dim=0) |
| SFFR4 | intmd_linspace (const SFFR4 &start, const SFFR4 &end, Size nstep, Size dim=0) |
| WFFR4 | dynamic_linspace (const WFFR4 &start, const WFFR4 &end, Size nstep, Size dim=0) |
| WFFR4 | intmd_linspace (const WFFR4 &start, const WFFR4 &end, Size nstep, Size dim=0) |
| SSR4 | dynamic_linspace (const SSR4 &start, const SSR4 &end, Size nstep, Size dim=0) |
| SSR4 | intmd_linspace (const SSR4 &start, const SSR4 &end, Size nstep, Size dim=0) |
| SWR4 | dynamic_linspace (const SWR4 &start, const SWR4 &end, Size nstep, Size dim=0) |
| SWR4 | intmd_linspace (const SWR4 &start, const SWR4 &end, Size nstep, Size dim=0) |
| WSR4 | dynamic_linspace (const WSR4 &start, const WSR4 &end, Size nstep, Size dim=0) |
| WSR4 | intmd_linspace (const WSR4 &start, const WSR4 &end, Size nstep, Size dim=0) |
| WWR4 | dynamic_linspace (const WWR4 &start, const WWR4 &end, Size nstep, Size dim=0) |
| WWR4 | intmd_linspace (const WWR4 &start, const WWR4 &end, Size nstep, Size dim=0) |
| Quaternion | dynamic_linspace (const Quaternion &start, const Quaternion &end, Size nstep, Size dim=0) |
| Quaternion | intmd_linspace (const Quaternion &start, const Quaternion &end, Size nstep, Size dim=0) |
| MillerIndex | dynamic_linspace (const MillerIndex &start, const MillerIndex &end, Size nstep, Size dim=0) |
| MillerIndex | intmd_linspace (const MillerIndex &start, const MillerIndex &end, Size nstep, Size dim=0) |
| Tensor | dynamic_linspace (const Tensor &start, const Tensor &end, Size nstep, Size dim=0) |
| Tensor | intmd_linspace (const Tensor &start, const Tensor &end, Size nstep, Size dim=0) |
| Scalar | dynamic_linspace (const Scalar &start, const Scalar &end, Size nstep, Size dim=0) |
| Scalar | intmd_linspace (const Scalar &start, const Scalar &end, Size nstep, Size dim=0) |
| Tensor | base_linspace (const Tensor &start, const Tensor &end, Size nstep, Size dim=0) |
| Vec | dynamic_logspace (const Vec &start, const Vec &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| Vec | intmd_logspace (const Vec &start, const Vec &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| Rot | dynamic_logspace (const Rot &start, const Rot &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| Rot | intmd_logspace (const Rot &start, const Rot &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| WR2 | dynamic_logspace (const WR2 &start, const WR2 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| WR2 | intmd_logspace (const WR2 &start, const WR2 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| R2 | dynamic_logspace (const R2 &start, const R2 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| R2 | intmd_logspace (const R2 &start, const R2 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| SR2 | dynamic_logspace (const SR2 &start, const SR2 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| SR2 | intmd_logspace (const SR2 &start, const SR2 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| R3 | dynamic_logspace (const R3 &start, const R3 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| R3 | intmd_logspace (const R3 &start, const R3 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| SFR3 | dynamic_logspace (const SFR3 &start, const SFR3 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| SFR3 | intmd_logspace (const SFR3 &start, const SFR3 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| R4 | dynamic_logspace (const R4 &start, const R4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| R4 | intmd_logspace (const R4 &start, const R4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| SFFR4 | dynamic_logspace (const SFFR4 &start, const SFFR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| SFFR4 | intmd_logspace (const SFFR4 &start, const SFFR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| WFFR4 | dynamic_logspace (const WFFR4 &start, const WFFR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| WFFR4 | intmd_logspace (const WFFR4 &start, const WFFR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| SSR4 | dynamic_logspace (const SSR4 &start, const SSR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| SSR4 | intmd_logspace (const SSR4 &start, const SSR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| SWR4 | dynamic_logspace (const SWR4 &start, const SWR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| SWR4 | intmd_logspace (const SWR4 &start, const SWR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| WSR4 | dynamic_logspace (const WSR4 &start, const WSR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| WSR4 | intmd_logspace (const WSR4 &start, const WSR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| WWR4 | dynamic_logspace (const WWR4 &start, const WWR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| WWR4 | intmd_logspace (const WWR4 &start, const WWR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| Quaternion | dynamic_logspace (const Quaternion &start, const Quaternion &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| Quaternion | intmd_logspace (const Quaternion &start, const Quaternion &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| MillerIndex | dynamic_logspace (const MillerIndex &start, const MillerIndex &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| MillerIndex | intmd_logspace (const MillerIndex &start, const MillerIndex &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| Tensor | dynamic_logspace (const Tensor &start, const Tensor &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| Tensor | intmd_logspace (const Tensor &start, const Tensor &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| Scalar | dynamic_logspace (const Scalar &start, const Scalar &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| Scalar | intmd_logspace (const Scalar &start, const Scalar &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| Tensor | base_logspace (const Tensor &start, const Tensor &end, Size nstep, Size dim=0, const CScalar &base=10.0) |
| Vec | normalize_gcd (const Vec &a) |
| | Normalize a tensor by its greatest common denominator.
|
| Rot | normalize_gcd (const Rot &a) |
| WR2 | normalize_gcd (const WR2 &a) |
| R2 | normalize_gcd (const R2 &a) |
| SR2 | normalize_gcd (const SR2 &a) |
| R3 | normalize_gcd (const R3 &a) |
| SFR3 | normalize_gcd (const SFR3 &a) |
| R4 | normalize_gcd (const R4 &a) |
| SFFR4 | normalize_gcd (const SFFR4 &a) |
| WFFR4 | normalize_gcd (const WFFR4 &a) |
| SSR4 | normalize_gcd (const SSR4 &a) |
| SWR4 | normalize_gcd (const SWR4 &a) |
| WSR4 | normalize_gcd (const WSR4 &a) |
| WWR4 | normalize_gcd (const WWR4 &a) |
| Quaternion | normalize_gcd (const Quaternion &a) |
| MillerIndex | normalize_gcd (const MillerIndex &a) |
| Tensor | normalize_gcd (const Tensor &a) |
| Scalar | normalize_gcd (const Scalar &a) |
| Tensor | outer (const Tensor &, const Tensor &) |
| Tensor | outer (const Tensor &) |
| R2 | outer (const Vec &, const Vec &) |
| R2 | outer (const Vec &) |
| R4 | outer (const R2 &, const R2 &) |
| R4 | outer (const R2 &) |
| SSR4 | outer (const SR2 &, const SR2 &) |
| SSR4 | outer (const SR2 &) |
| Scalar | tr (const Tensor &) |
| Scalar | tr (const R2 &) |
| Scalar | tr (const SR2 &) |
| Scalar | tr (const WR2 &) |
| Vec | unit (const Vec &a, const std::optional< CScalar > &eps=std::nullopt) |
| Rot | unit (const Rot &a, const std::optional< CScalar > &eps=std::nullopt) |
| WR2 | unit (const WR2 &a, const std::optional< CScalar > &eps=std::nullopt) |
| R2 | unit (const R2 &a, const std::optional< CScalar > &eps=std::nullopt) |
| SR2 | unit (const SR2 &a, const std::optional< CScalar > &eps=std::nullopt) |
| R3 | unit (const R3 &a, const std::optional< CScalar > &eps=std::nullopt) |
| SFR3 | unit (const SFR3 &a, const std::optional< CScalar > &eps=std::nullopt) |
| R4 | unit (const R4 &a, const std::optional< CScalar > &eps=std::nullopt) |
| SFFR4 | unit (const SFFR4 &a, const std::optional< CScalar > &eps=std::nullopt) |
| WFFR4 | unit (const WFFR4 &a, const std::optional< CScalar > &eps=std::nullopt) |
| SSR4 | unit (const SSR4 &a, const std::optional< CScalar > &eps=std::nullopt) |
| SWR4 | unit (const SWR4 &a, const std::optional< CScalar > &eps=std::nullopt) |
| WSR4 | unit (const WSR4 &a, const std::optional< CScalar > &eps=std::nullopt) |
| WWR4 | unit (const WWR4 &a, const std::optional< CScalar > &eps=std::nullopt) |
| Quaternion | unit (const Quaternion &a, const std::optional< CScalar > &eps=std::nullopt) |
| MillerIndex | unit (const MillerIndex &a, const std::optional< CScalar > &eps=std::nullopt) |
| Tensor | unit (const Tensor &a, const std::optional< CScalar > &eps=std::nullopt) |
| Scalar | unit (const Scalar &a, const std::optional< CScalar > &eps=std::nullopt) |
| Tensor | vol (const Tensor &) |
| R2 | vol (const R2 &) |
| SR2 | vol (const SR2 &) |
| WR2 | vol (const WR2 &) |
| TraceableSize | operator* (const TraceableSize &lhs, const TraceableSize &rhs) |
| bool | operator== (const TraceableSize &lhs, const TraceableSize &rhs) |
| bool | operator!= (const TraceableSize &lhs, const TraceableSize &rhs) |
| bool | operator== (const TraceableTensorShape &lhs, const TraceableTensorShape &rhs) |
| bool | operator!= (const TraceableTensorShape &lhs, const TraceableTensorShape &rhs) |